Apostila pcj-n1

www.abutua.
com
Cursos Abtua
Preparatrio para Certificao Java
Contedo
Introduo ..................................................................................................................................... 6 Caractersticas ............................................................................................................................... 7 Histrico ........................................................................................................................................ 7 Aplicaes...................................................................................................................................... 8 Composio ................................................................................................................................... 9 Funcionamento ........................................................................................................................... 10 Ol Mundo! ................................................................................................................................. 11 Dissecando o processo ................................................................................................................ 11 O que pode dar errado ................................................................................................................ 12 Operador ponto (.) ...................................................................................................................... 18 Modificadores de acesso ............................................................................................................. 18 Encapsulamento .......................................................................................................................... 19 Interface ...................................................................................................................................... 20 Acessores get, set, is, has ........................................................................................................ 20 Pacotes ........................................................................................................................................ 21 Declarando um pacote ............................................................................................................ 21 Importaes ............................................................................................................................ 22 Declaraes ................................................................................................................................. 23 Blocos .......................................................................................................................................... 23 Identificadores ou Variveis ........................................................................................................ 24 Escopo ......................................................................................................................................... 24 Funes, Mtodos ou Procedimentos ........................................................................................ 25 Operador this .......................................................................................................................... 26 Passagem por Valor e passagem por referncia ..................................................................... 26 Tipos Primitivos ou Bsicos ......................................................................................................... 28 Inteiros e Ponto Flutuante ...................................................................................................... 28 Boleano ................................................................................................................................... 30 Caractere ................................................................................................................................. 30 Objetos ........................................................................................................................................ 32 Criando um objeto novo ......................................................................................................... 32 Ancestral Comum .................................................................................................................... 33 Enumerao ................................................................................................................................ 33 www.abutua.com
Cursos Abtua
Mtodos de Enum ................................................................................................................... 34 Enums avanados .................................................................................................................... 34 Arrays .......................................................................................................................................... 35 Acessando os Elementos por ndices ...................................................................................... 35 Array Multidimensional........................................................................................................... 36 Copiando Arrays ...................................................................................................................... 37 Strings .......................................................................................................................................... 37 Manipuladores de String ......................................................................................................... 38 Tamanho mximo de Arrays e Strings......................................................................................... 39 Operadores de Atribuio ........................................................................................................... 40 Operadores de atribuio compostos ..................................................................................... 40 Operadores Lgicos Relacionais .................................................................................................. 41 Menor que (<) ......................................................................................................................... 41 Menor ou igual a (<=) .............................................................................................................. 41 Maior que (>)........................................................................................................................... 41 Maior ou igual a (>=) ............................................................................................................... 42 Igualdade (==).......................................................................................................................... 42 Diferente (!=) ........................................................................................................................... 42 Operadores Matemticos ........................................................................................................... 42 Diviso inteira.......................................................................................................................... 43 Operadores Unrios .................................................................................................................... 43 Operadores lgicos ..................................................................................................................... 43 E (&&) ...................................................................................................................................... 44 Ou (||) ..................................................................................................................................... 44 Negao (!) .............................................................................................................................. 44 if - else ......................................................................................................................................... 45 switch-case .................................................................................................................................. 46 Operador ? .................................................................................................................................. 47 while ............................................................................................................................................ 48 do while .................................................................................................................................... 48 for ................................................................................................................................................ 48 for each..................................................................................................................................... 49 Iterator ........................................................................................................................................ 49 Quebrar e Continuar ................................................................................................................... 50
www.abutua.com
Cursos Abtua
Laos aninhados .......................................................................................................................... 51 Classes ......................................................................................................................................... 52 Modificador Esttico ............................................................................................................... 52 Modificador Final .................................................................................................................... 53 Herana de Classes ...................................................................................................................... 54 InstanceOf ............................................................................................................................... 56 Polimorfismo ............................................................................................................................... 56 Sobrecarga............................................................................................................................... 56 Sobrescrita............................................................................................................................... 58 Classes Abstratas ......................................................................................................................... 60 Mtodos Abstratos.................................................................................................................. 60 Interface ...................................................................................................................................... 61 Implement ............................................................................................................................... 62 Extend...................................................................................................................................... 63 Exemplo composto ...................................................................................................................... 63 Associaes ................................................................................................................................. 64 Composio ............................................................................................................................. 64 Agregao................................................................................................................................ 65 Excees ...................................................................................................................................... 67 Exception ................................................................................................................................. 67 RuntimeException e Error ....................................................................................................... 67 Declarando Excees............................................................................................................... 67 Try-Catch ..................................................................................................................................... 67 Finally ...................................................................................................................................... 69 Throws ..................................................................................................................................... 69 Throw ...................................................................................................................................... 70 Assero (assert) ......................................................................................................................... 70 Complemento.............................................................................................................................. 71 O Framework de Colees .......................................................................................................... 73 Interfaces..................................................................................................................................... 73 Collection................................................................................................................................. 74 List ........................................................................................................................................... 74 Set............................................................................................................................................ 76 Queue ...................................................................................................................................... 76
www.abutua.com
Cursos Abtua
Map ......................................................................................................................................... 77 Implementaes e Wrappers ...................................................................................................... 78 Algoritmos: Comparao e Ordenao ....................................................................................... 80 Sobrecarregando equals e hashCode...................................................................................... 80 Comparable ............................................................................................................................. 81 Comparator ............................................................................................................................. 82 Genricos .................................................................................................................................... 82 Coringas e limites .................................................................................................................... 85 Remoo de tipo (type erasure).............................................................................................. 88 Interfaces de Entrada e Sada na Plataforma Java ................................................................... 89 Conceito de fluxo .................................................................................................................... 89 Manipulando bytes ................................................................................................................. 89 Manipulando caracteres ......................................................................................................... 92 Serializao.............................................................................................................................. 96 Sistema de Arquivos ................................................................................................................ 98 Interfaces de Processamento Concorrente (Threads) .............................................................. 101 Processos e Threads .............................................................................................................. 101 Estados .................................................................................................................................. 102 Classes e Interface ................................................................................................................. 103 Sincronizao entre Threads ................................................................................................. 104
www.abutua.com
Cursos Abtua
Mdulo 1 Captulo 1
Conceitos Bsicos da Tecnologia Java
Introduo
A tecnologia Java compreende no apenas uma linguagem de programao, mas toda uma plataforma. Ela envolve todas as etapas desde seu desenvolvimento, distribuio e execuo. Fazem parte do portiflio de tecnologias Java: Linguagem de programao Java Ambientes de Execuo (Java Runtime, JRT) o O JRT executa as aplicaes em uma mquina virtual, abstraindo os recursos da plataforma nativa. Ambiente de Desenvolvimento (Java Development Kit, JDK) o O ambiente de desenvolvimento instalado em computadores pessoais e de escritrio. Ele disponibiliza as ferramentas bsicas para compilar, depurar (profile, debug), documentar e empacotar as aplicaes Biblioteca de algoritmos e utilidades (Application Programming Interface, API) o APIs j presentes na plataforma (JRT) como javax.swing para ambientes grficos java.net para web e redes de computadores java.util.concurrency para trabalhar com programao concorrente o APIs de terceiros como org.apache.commons.logging para lidar com logs org.json para trabalhar com javascript/Ajax
O ambiente de execuo, JRE, modularizado e pode ser composto por conjuntos de mdulos indicados para ambientes especficos: O J2SE o ambiente de execuo mnimo padro, indicado para rodar aplicaes cotidianas em computadores pessoais (desktops) O J2EE acrescenta os mdulos necessrios para a execuo de aplicaes empresariais, possivelmente distribudas (que acessam servidores remotos, como servidores de banco de dados). Normalmente instalado por aplicaes terceiras sobre o J2SE, para computadores de escritrio (workstations). Ex.: GlassFish. O RTSJ traz alteres no funcionamento do ambiente de gerenciamento de memria do J2SE tornando-o apto a executar aplicaes com requisitos de tempo real. Normalmente instalado em computadores com funo especializada com fins industrial/cientfico. O J2ME um subconjunto do J2SE, com mais opes de modularizao, adaptvel para execuo em ambientes com restries de memria/processamento. Possui mdulos especficos configurados por fabricantes de dispositivos mveis ou embarcados.
www.abutua.com
Cursos Abtua
O ambiente de desenvolvimento, JDK, estende o ambiente de execuo e acrescenta diversas ferramentas para o auxlio do desenvolvedor para compilar, depurar, documentar, empacotar e distribuir suas aplicaes. Os mdulos J2EE, JRTS e J2ME tambm se aplicam ao JDK acresentando as ferramentas de desenvolvimento e depurao especficas de cada mdulo.
Caractersticas
Algumas das caractersticas da linguagem de programao Java so: Linguagem de propsito geral1; Orientada a objetos; Concorrente2; Distribuda3; Segura4; Segue a filosofia escreva uma vez, rode em qualquer lugar; o Sinnimos: de arquitetura neutra, portvel.
A sintaxe da linguagem Java assemelha-se muito da sintaxe do C++. Contudo, ela procurou manter-se descomplicada utilizando mecanismos de herana simples, o mnimo de dependncia do sistema operacional e sem expor tarefas de baixo nvel (como manipulao ponteiros, diretivas de sistema etc) aos programadores. A execuo segura, pois so acrescentadas verificaes implcitas aos erros mais comuns, as bibliotecas utilizam interfaces de acesso padronizadas e existem verificaes de nvel de permisso de acesso a recursos do computador. A linguagem ao longo do tempo tambm agregou as melhores caractersticas de outras linguagens como Smalltalk, Objective-C, C#, Eiffel, etc.
Histrico
A Plataforma Java foi lanada publicamente pela primeira vez em 1995 pela Sun Microsystems (que agora pertence Oracle). Desde ento ela se encontra em constante transformao e aperfeioamento.
Uma linguagem de propsito geral serve para programar para diversos propsitos, como aplicaes visuais, servios etc. o contrrio de uma linguagem especfica como, por exemplo, SQL ou VHDL, sendo a primeira especfica para banco de dados e a segunda para descrever hardware e autmatos. 2 Concorrncia a possibilidade de se ter mais que uma linha de execuo executando os cdigos do programa. No contexto de l. de programao, quer dizer que a linguagem fornece mecanismos de criao e controle de mais de uma linha de execuo (do ingls, multithreaded). 3 Uma linguagem distribuda indica que a linguagem e o ambiente de execuo possuem mecanismos nos quais um programa pode fazer referncia a objetos e mtodos que no pertencem ao sua unidade de execuo, ou seja, objetos e mtodos em outros executveis ou at em outros computadores em uma rede. 4 Segura por vrios motivos: no expe o baixo nvel para o programador, tanto o ambiente de compilao quanto o de execuo fazem verificaes para garantir que no h violaes de permisso de acesso, leitura e escrita para qualquer recurso (como arquivos, pastas, conexes de rede, memria etc.).
www.abutua.com
Cursos Abtua
Ao longo dos anos a linguagem passou por diversas mudanas, agregando funcionalidades. Em 2007 consolidou-se um comit independente que dirige os caminhos da especificao da linguagem e do ambiente de execuo, o Java Community Process. A primeira verso consolidade da linguagem veio com o lanamento do Java Second Edition (tambm conhecido como Java2, ou J2SE) que corresponde verso 1.2 at a 1.4. Um marco na histria do Java foi a verso 1.5 em 2004, conhecida como Java 5, que acrescentou mudanas na linguagem, novas funcionalidades, reviso da biblioteca de algoritmos, um direcionamento para simplificao da plataforma empresarial (Enterprise Edition), dentre outras novidades. Desde a verso 1.5, os lanamentos (releases) so contados com a verso menor em destaque, exemplo: Java 6 para v1.6 em 2006, Java 7 para v1.7 em 2011 e assim por diante. Algumas das mudanas ocorridas na linguagem afetaram o estilo de programao Java. Essas mudanas distinguem claramente o antes e o depois da verso 1.5. Pode-se citar como grandes diferenas: Mecanismos de Genricos; Linguagem de Marcao ou Atributos; Enumeradores de tipo forte.
Aplicaes
Graas a sua flexibilidade, tanto da linguagem quanto do ambiente de execuo, as aplicaes em Java tornaram-se muito populares e abrangentes. Alguns exemplos: Aplicaes web o Applets: aplicaes simples, carregadas diretamente na pgina web; o JNLP: aplicaes mais complexas, instaladas a partir de uma pagina web; o Java FX: aplicaes ricas com propsitos visuais e multimdia, podem rodar diretamente na pgina web ou serem instalados; Aplicaes desktop o Aplicaes de modo texto, que rodam em janelas de terminal; o Aplicaes grficas AWT, Swing, SWT, etc como Eclipse e o Netbeans; Aplicaes servidoras o Servidores de Web como Apache Tomcat, Jetty, JBoss Web; o Servidores de Aplicao como Glassfish, JOnAS, JBoss AS, Apache Gernimo o Servidor de servio (SOA) como o IBM Web Sphere; Aplicaes embarcadas o Aplicativos de celular e Smartphone; o Jogos para celular e Smartphone; Tablets o Google Android usa a linguagem de programao Java para sua prpria mquina virtual (Dalvik).
www.abutua.com
Cursos Abtua
De fato, como a Plataforma Java cobre praticamente todas as reas de aplicaes computacionais, e sua linguagem ser muito parecida com C++ e C#, seu aprendizado no considerado um obstculo para programadores j com alguma experincia, e at mesmo programadores iniciantes que j tenham tido algum contado com linguagens tambm derivadas de C/C++.
Composio
O grande sucesso do Java deve-se principalmente por alcanar o objetivo escreva uma vez, rode em qualquer lugar. A aplicaes escritas na linguagem Java so compiladas em um cdigo de bytes (bytecode), feitos para serem executados em uma mquina virtual (Java Virtual Machine, JVM). Dessa forma, apenas a JVM precisa ser escrita para o sistema operacional alvo. Existem JVMs para Linux, FreeBSD, Mac, Windows entre outros, fazendo com que uma aplicao Java rode em todos esses sistemas sem alterao ou necessidade de recompilao. O Ambiente de Execuo Java composto essencialmente por: Mquina Virtual Java (JVM) o Um conjunto de bibliotecas de sistema (nativas) necessrias para simular um processador, pilha, fila, contador de programa, sistemas de entrada e sada, leitura e escrita de memria virtual para executar os bytecodes das aplicaes; O ambiente de execuo (JRT) o Compreende o conjunto de aplicaes e bibliotecas dinmicas, dependentes do sistema op., que formam os requisitos iniciais necessrios para a execuo da JVM (no sistema Windows os principais executveis so java.exe e javaw.exe). Tambm podem compreender as aplicaes necessrias para se compilar o cdigo fonte em bytecodes (compilador), alm de outras aplicaes como ferramentas para compactar dados (pack200), manipulao de certificados e autenticao de pacotes (keytool), servios de comunicao e execuo distribuda (orbd e rmid) etc. Bliblioteca de algoritmos (API) o Vasta coleo de classes para diversos algoritmos (filas, pilhas, contadores, manipuladores de imagem, sistema de arquivos etc), alm das classes bsicas do ncleo do Java, todas em formato de bytecode.
Nota: Por conveno, todas as bibliotecas do ncleo comum da plataforma devem comear com java e javax, as bibliotecas de terceiros e de implementao devem comear com o nome da empresa ou organizao, ex.: org.ong.CORBA, com.sun.net.httpserver. Algumas bibliotecas de terceiros podem ser includas na biblioteca padro, mas mantendo seu nome original.
www.abutua.com
Cursos Abtua
10
JRT
Aplicao Java APIs: Colees, Swing, Sockets etc
JVM: CPU, Memria e Recursos Virtuais Plataforma: Linux, Windows, Mac etc
Funcionamento
O ncleo essencial do Java consiste das aplicaes (bytecodes) e da JVM. O processo de gerao e execuo das aplicaes consiste em 1. Compilar o cdigo fonte escrito em linguagem Java (.java) gerando os arquivos com os bytecodes (.class) 2. Carregar o arquivo com os bytecodes na mquina virtual (Class Loader) 3. Analisar os bytecodes a. Verificar se os tipos esto corretos b. Verificar se no h leitura ou escrita fora dos limites (ex.: underflow e overflow em vetores) c. Verificar se no h operaes de entrada e sada para recursos no permitidos (ex.: escrever um arquivo em um diretrio/pasta protegido) 4. Interpretar ou compilar (JIT) o cdigo para as instrues do computador real
Arquivos Compilador .java
Arquivos .class
Interpretador Class Loader
Executor
Verificao
Compilador (JIT)
Os bytecodes so nmeros de 0 a 255, representados em hexadecimal (de 00 a FF), eles significam instrues para um processador neutro dentro da JVM, ao contrrio dos binrios especficos dos sistemas operacionais, os bytecodes foram desenvolvidos para carregar informaes extras, ou meta informaes, que ajudam a descrever os dados e seus tipos, viabilizando os testes de segurana e integridade no cdigo antes que ele seja executado.
www.abutua.com
Plataforma
Cursos Abtua
11
Mdulo 1 Captulo 2
Uma Simples Aplicao Exemplo
Ol Mundo!
O processo de criao de uma aplicao Java bem simples: 1. Obtenha e instale o JDK conveniente para seu sistema, na maioria dos casos basta consultar a pgina oficial da Oracle5; 2. Utilizando uma aplicao de edio de texto, crie um arquivo chamado Hello.java; 3. O contedo do arquivo ser:
//Aplicacao de Exemplo public class Hello { public static void main (String args[]) { System.out.println(Hello World!); } }
4. Salve o arquivo e utilize o compilador Java (JDK), isso ir gerar o arquivo com os bytecodes;
> javac Hello.java Hello.class
5. Execute a aplicao atrvs do lanador (ex.: java.exe)

> java Hello
6. Dever ser impresso no janela do prompt de comandos

Hello World!
Dissecando o processo
Linhas de comentrios: so linhas que no sero interpretadas pelo compilador, servem para o programador incluir mensagens ou avisos sobre algum aspecto do cdigo, ou para remover uma linha do processo de compilao durante testes. Como no exemplo anterior elas podem ser: Linha por linha: // Texto linha1 // Texto linha2 Blocos de texto: /* Texto1 Texto2 */
Declarao de classe: na linguagem de programao Java cada arquivo deve definir uma classe, o nome do arquivo precisa ser exatamente igual ao nome da classe que ele define (case sensitive).
[2012-02-17] - http://www.oracle.com/technetwork/java/javase/downloads/index.html
www.abutua.com
Cursos Abtua
12
Arquivo Hello.java class Hello { Arquivo Janela.java class Janela { ...
Declarao de mtodos e mtodo principal: cada classe pode declarar um ou mais mtodos, em qualquer visibilidade (pblico, privado, protegido e pacote), mas uma aplicao necessita de pelo menos um mtodo pblico (public), sem retorno (void), principal (main), declarado como esttico (static) e com um argumento que seja um vetor de Strings (String args[]) public static void main(String args[])
O corpo do programa: o contedo do mtodo principal o corpo do programa, nele ser feita a sequncia que far seu programa fazer o que foi determinado, no caso do exemplo foi utilizado o mtodo println disponvel atravs da API System.out System.ou.println(Hello World)
A execuo do programa: ao utilizar o JRE para executar sua aplicao (o lanador) o mesmo ir incluir todos os arquivos de bytecode que encontrar no local de onde for iniciado (no caso ir carregar automaticamente o arquivo Hello.class), como argumento do lanador precisa saber apenas o nome da classe que contenha um mtodo principal java Hello
O que pode dar errado

Durante o processo de criao e execuo de uma aplicao Java podem ocorrer dois tipos de erros: Erros de compilao: Esses erros so emitidos pelo compilador (javac) ao processar o cdigo fonte. Ele relata erros e avisos de tipo, sintaxe e lgica. Possuem a seguinte forma:
[Nome do arquivo]:[linha]:[mensagem] symbol: [assinatura de quem causou o erro] location: [classe e pacote que contm a declarao de symbol] [Uma dica da localizao do erro dentro da linha indicada]
Erros de Execuo: Esses erros so emitidos durante a execuo da aplicao, eles relatam erros que dependem de contexto (dinmicos) e que s podem ocorrer durante a execuo. Possuem a seguinte forma: o Normalmente so frases diretas como: Cant find class XXXXX, Array out of limits ou o Descries detalhadas que percorrem todos os mtodos e classes envolvidas no erro (stack trace): Exception in thread Main, caused by ... caused by ... caused by ...
Nem sempre o processo de interpretao dos erros direto, mas com a prtica os programadores habituam-se s mensagens.
www.abutua.com
Cursos Abtua
13
Mdulo 2 - Captulo 3
Conceitos de Engenharia de Software
A engenharia de software consiste em identificar e reutilizar tcnicas de programao no desenvolvimento ou aperfeioamento de solues de computao. A palavra chave da engenharia de software reutilizao, ou o conceito: escreva uma vez, utilize vrias vezes. Exemplos de abstrao e reutilizao na histria da programao: No incio da computao, os cdigos de mquina e algoritmos em linguagem Assembly que eram repetidos com frequncia, eram agrupados em macros dando origem aos MacroAssemblers. Algum tempo depois surgiram as linguagens de alto nvel como Fortran, LISP e C que geravam cdigo Assembly atravs de uma linguagem mais sofisticada. Isso permitiu formular cdigos e algoritmos mais complexos. Os cdigos que eram frequentemente repetidos, ou que podiam ser reutilizados em outras aplicaes, foram agrupados em bibliotecas de algoritmos e APIs (Interface de Programao de Aplicao), sendo esta ltima um conjunto de funes para execuo de tarefas implementando um ou mais algoritmos. Nos anos 80/90 surgiram as linguagens chamadas de orientadas a objetos, como SmallTalk, C++ e Java. A orientao a objeto veio propor outra forma de programao, que visava facilitar ainda mais a identificao de cdigo reutilizvel. Para citar como exemplo, a Plataforma Java possui uma das mais ricas colees de algoritmos, APIs e Frameworkers, sendo esta ltima um conjunto de APIs para desenvolvimento de aplicaes em alto nvel. Como exemplo a plataforma de desenvolvimento de aplicaes grficas (de janelas) AWT/Swing e JavaFX, aplicaes distribudas Jini etc. Plataforma Framework API Algoritmos API Algoritmos
A programao de aplicaes composta por duas etapas:
www.abutua.com
Cursos Abtua
14
Anlise: identifica os requisitos da aplicao, ou o qu se deseja que a aplicao faa. Na linguagem de modelamento universal (UML) so descritos como atores, atividades, objetos e comportamentos. Desenvolvimento: aps identificados e definidos os itens da anlise, o desenvolvimento descreve, por exemplo, como uma atividade entre um ator e um objeto ser executada, quais sero as mensagens trocadas, sua ordem etc. Abstraindo e, possivelmente, reutilizando conceitos e tcnicas.
A palavra chave da programao abstrao, a elaborao de tcnicas e algoritmos que possibilitem a eficaz execuo de determinada tarefa.
www.abutua.com
Cursos Abtua
15
Mdulo 2 Captulo 4
Estruturas da Linguagem de Programao Java
A linguagem de programao Java uma linguagem de programao orientada a objetos. Objetos6 so abstraes de suas contrapartes do mundo real. Denomina-se de objeto tudo aquilo que possua atributos ou estados (state) e aes ou comportamento (behavior). Ex.: Um carro pode possuir o atributo modelo, e os estados velocidade atual e marcha. Podendo fazer os aes acelerar, frear, aumentar marcha etc. Os elementos identificados durante a anlise e descritos no desenvolvimento precisam ser efetivados em um programa (ou aplicao). A linguagem de programao serve para esse propsito. Uma linguagem define um conjunto de palavras e regras de sintaxe para que se possa efetivar o desenvolvimento. Para descrever os objetos, seus atributos e comportamentos, so utilizadas classes. As classes servem a trs conceitos fundamentais: Encapsulamento: agrupam estados e comportamentos pertencentes ou inerentes a um mesmo objeto. Herana: prov como expressar relaes entre objetos como herana (pai-filho, um) ou composio. Polimorfismo: dada uma relao de herana faz com que um objeto do tipo pai modifique seu comportamento para refletir a viso do filho.
A descrio dos objetos feita atravs das classes, os atributos sero os campos (fields), representados por variveis de algum tipo. As aes sero os mtodos (methods), que so escritos como funes. As funes podem receber parmetros e retornar um valor. Ambos, campos e mtodos, so chamados de membros do objeto.
Por simplicidade, atores e objetos so ambos tratados apenas como objetos.
www.abutua.com
Cursos Abtua
16
Objeto ou Instncia
Classe
Campos Mtodos
membros
Meta objeto ou Classe A sintaxe de uma classe em Java :
<modificador>* class <nome> { <campos>* <construtor>* <mtodos>* }
Objeto
Estados/Atributos
Aes/Comportamentos
Onde: Campos:
<modificador>* <tipo> <nome> [= <valor>];
Mtodos:
<modificador>* <tipo_retorno> <nome> (<argumentos>*) { <declaraes>* }
Observao: Caso o tipo do retorno seja diferente de void, obrigatrio que haja pelo menos uma declarao de retorno (return). Construtores:
[<modificador>] <nome_da_classe> (<argumentos>*) { <declaraes>* }
www.abutua.com
Cursos Abtua
17
Observaes: Um construtor um mtodo especial sem tipo de retorno. Sua funo um ser um ponto inicial para configurao do objeto antes que ele seja utilizado. Na maioria dos casos, o compilador Java ir gerar automaticamente um construtor vazio. *: denota zero ou mais do mesmo elemento. <>: denota um elemento []:denota um elemento opcional (zero ou um)
www.abutua.com
Cursos Abtua
18
Mdulo 2 Captulo 5
Visibilidade, Encapsulamento e Pacotes
Operador ponto (.)

O operador ponto (.) um operador de pertinncia, ou seja, indica que a expresso a direita do ponto pertence expresso a esquerda do ponto. Por exemplo: dado A.B indica que B pertence A. Na linguagem Java o uso mais comum para indicar o acesso aos membros de uma classe ou de um objeto. Exemplo:
System.out.println(); //indica que estamos acessando o mtodo println // que pertence ao campo out // que pertence classe System
Modificadores de acesso
Os campos, mtodos e classes podem ter sua visibilidade ou acesso filtrados. Esses filtros de acesso podem ser: Privado (private): pode ser acessado apenas por outros membros da mesma classe Protegido (protected): pode ser acessado por membros da mesma classe e em de classes em relaes de herana um (ou pai-filho) Pacote (package)7: pode ser acessado por membros da mesma classe e por outras classes do mesmo pacote Pblico (public): pode ser acessado por membros da mesma classe e por qualquer outra classe em qualquer pacote
Ateno: apenas permitido um modificador de acesso por classe ou membro. Exemplos:

public class Foo { public int x; private int y; protected int doFoo() { return x + y; } void Init(int a, int b) { //package x = a; y = b; } }
Casos:
Quando o modificador de acesso omitido, pacote ser o nvel de visibilidade padro.
www.abutua.com
Cursos Abtua
19
Uma varivel f do tipo Foo o Pode acessar o campo f.x o Pode acessar f.Init apenas se a varivel for declarada no mesmo pacote Uma classe Bar herda Foo (Bar extends Foo, um) o Os mtodos de Bar podem acessar Foo.x, Foo.doFoo o Os mtodos de Bar s podero acessar Foo.Init se Bar estiver no mesmo pacote de Foo Uma classe Cog no mesmo pacote de Foo o Os mtodos de Cog podem acessar Foo.x e Foo.Init
Encapsulamento
O conjunto de campos e mtodos, mais os modificadores, criam as condies para o encapsulamento dos objetos. O encapsulamento significa a quantidade de informaes caractersticas de um objeto que esto contidos no prprio objeto. Um bom encapsulamento gera objetos autossuficientes, com tarefas especficas que requisitam e informam apenas o estritamente necessrio atravs de interfaces. Ou, um objeto que resolva suas dependncias com outros objetos de forma subjetiva, transparente, com o mnimo de interferncia por parte do utilizador do objeto. Exemplo: Um sistema de log (ex. java.util.logging.Logger) O desenvolvedor gera um arquivo de configurao com as caractersticas do sistema de log. Esse arquivo pode ser feito uma nica vez e carregado automaticamente para todos os objetos que forem criados. Para cada objeto da aplicao que o desenvolvedor necessite de um log, ele precisa informar apenas o nome do log e usar um dos mtodos de adio de informao (como info, fine, severe etc). Todo o trabalho necessrio de gerar arquivos no sistema operacional, ordenar as mensagens, escrever no arquivo, entre outras, so tarefas internas de Logger e no so expostas ao usurio. As tarefas internas delegam para outros objetos especficos como: Java.io.File que o responsvel por efetivamente criar o arquivo e o java.io.OutputStream, responsvel por escrever dados no arquivo aberto por File etc.
www.abutua.com
Cursos Abtua
20
Interface
Interface um conjunto de mtodos consistentes para acessar as funcionalidades de um objeto. Uma interface ajuda a ocultar a implementao do objeto, ou seja, no importa como, ou a sequncia dos algoritmos, ou os campos utilizados do objeto, os mtodos da interface sero sempre iguais. Por exemplo, torna-se possvel trocar objetos que possuam a mesma interface sem necessidade de se reprogramar toda a aplicao. Interface X Obj. A Objeto Utilizador
Interface Y Obj. B
Acessores get, set, is, has

Uma forma de se fazer o encapsulamento de objetos com interfaces seguindo a conveno do POJO (Plain Old Java Objects). Nesta conveno, so definidos mtodos que expe os campos do objeto seguindo um padro de prefixos para relacionar os mtodos com os campos: get e set: so prefixos para os mtodos de leitura e escrita respectivamente:
[tipo_do_campo] get[NomeDoCampo]() void set[NomeDoCampo]([tipo_do_campo][nome])
is e has: so prefixos para expresses lgicas que retornam um tipo booleano. A escolha entre is () e has (tem/possui) depende de qual faz mais sentido dependendo do contexto. O padro utilizar sempre que possvel o is. Seguem o padro:
boolean is[NomeDoCampo]() boolean has[NomeDoCampo]()
Exemplo:
public class Gato { private int idade; private String nome; private boolean destro; public int getIdade() { return idade; } public void setIdade(int idade) {
www.abutua.com
Cursos Abtua
21
this.idade = idade; } public boolean isDestro() { //Destro? return destro; } public String getNome() { return nome; } public void setNome(String nome) { this.nome = nome; } }
Note que o nome dos campos e dos mtodos seguem o padro camelCase, ou seja, comeam sempre com a primeira letra da primeira palavra em minsculo e primeira letra das palavras seguintes em maisculo (ex.: nomeDoCampo). Note tambm que ao se acrescentar os prefixos (em minsculo) a primeira letra do nome do campo passa a ser em maiscula (ex. getNomeDoCampo).
Pacotes
Para organizar e distinguir melhor os conjuntos de objetos pertencentes a um algoritmo, ou um conjunto de algoritmos pertencentes a uma API e assim por diante, a linguagem Java prope o conceito de pacotes. Os pacotes esto diretamente relacionados hierarquia de diretrios. Cada arquivo em um diretrio corresponde a uma classe em um pacote. A correspondncia entre o nome do arquivo e o nome da classe, e entre o nome do pacote e o nome do diretrio, devem ser idnticas. Por conveno, todos os nomes de pacotes devem ser em minsculo. Nas declaraes de pacotes e importao, a separao entre as hierarquias deve ser feita com o operador ponto. Assim como os membros de uma classe, as classes em um pacote podem ter sua visibilidade alterada pelo uso de modificadores.
Declarando um pacote
Mesmo que fisicamente cada classe seja representada em um arquivo dentro de um diretrio, o contedo do arquivo deve indicar o pacote ao qual pertence. Um arquivo que declara uma classe deve conter a seguinte sequncia:
[declarao do pacote]* <importaes> [declarao da classe]
Onde: Decalrao do pacote possui a sintaxe:
www.abutua.com
Cursos Abtua
22
package [hierarquia];
Caso seja omitido a classe far parte do pacote padro (default-package), uma espcie de pacote global ou raiz.
Importaes
Para se referenciar objetos que foram declarados em outros pacotes deve-se indicar sua localizao completa precedido a palavra chave import :
import [hierarquia].[Classe]
Para importar todas as classes de um pacote:

import [hierarquia].*
Nota: a importao de pacotes com * no recursiva, ou seja, no incluiro todos os subpacotes. O * importa apenas as classes pblicas do nvel dado. Deve-se tomar cuidado pos podem ocorrer colises entre o nome de classe definido no arquivo atual e importados. Exemplo: Package formas; /CodFonte /formas /Quadrado.java /Circulo.java /Aplicacao.java Package formas; public class Circulo { }
public class Quadrado { }
//pacote raiz import formas.Quadrado; import formas.Circulo; //ou import formas.*; public class App { } Nota: A partir da verso Java 5 foi incluso um novo tipo de importao: static import. Essa nova declarao serve para importar declaraes de campos estticos definidos em classes pblicas de outros pacotes. Contudo, ela deve ser utilizada apenas quando uma constante for frequentemente referenciada. Ex.: static import Java.lang.Math.PI
www.abutua.com
Cursos Abtua
23
Mdulo 3 Captulo 6
Conceitos bsicos de programao
Declaraes
Ou statements em ingls, so essencialmente as linhas de cdigo do programa. Nota: Linhas de cdigo aqui no significa literalmente um pargrafo, mas uma instruo mnima, ou unidade, para ser interpretada pelo compilador. A linguagem Java herda de C/C++ o uso de ponto-e-vrgula (;) para indicar o fim de uma declarao. Assim uma declarao todo cdigo que comea com elemento vlido (por ex. um tipo de dado, nome de classe, varivel etc) e termina com ;. Exemplos:
//cada uma das linhas abaixo so declaraes int a; double b = 3.5; //uma declarao pode conter expresses separadas por vrgula String nome1 = Joao, nome2 = Paulo;
Ateno: Algumas declaraes no terminam necessariamente com ponto-e-vrgula. Ex.: as declaraes de for, if, class, switch etc. Para esses casos, o fim do bloco (}) considerado o fim da declarao.
//Uma declarao for termina com o fim do bloco: } for(int i = 0; i <= 3; ++i) { System.out.print(i);//Esta uma declarao que termina com ; }
Blocos
Os blocos so delimitados entre chaves ({}), eles agrupam vrias declaraes dentro de um contexto. Blocos podem ser aninhados dentro de outros blocos. Os blocos podem fazer parte de expresses de controle, funes, classes etc. Ex.:
Public void foo() {.../*bloco do mtodo foo*/...} if(cond != false) { //bloco if do { .../*bloco do*/... }While(!cond2) }
Os blocos podem ser declarados independentes, dentro de outros blocos, servindo para isolar um subcdigo ou lgica separada do resto do algoritmo. Ex.:
Void doWork() { int a, b = 2; {//sub-bloco independente, isola a varivel c int c = b * 2;
www.abutua.com
Cursos Abtua
24
} //c no existe no bloco exterior a = 10; }
Identificadores ou Variveis
So os nomes dados aos objetos e valores. Eles esto associados a um tipo, participam em atribuies e em outras expresses. As variveis podem ser: De instncia: so os campos declarados nas classes. Tambm conhecidas como variveis no estticas. De classe: so os campos declarados nas classes que possuem o modificador esttico (static). Tambm conhecidas como variveis estticas. Locais: so as variveis declaradas no corpo dos blocos. Parmetros: so as variveis declaradas entre parnteses em uma funo.
Exemplos:
//a, b, c, x e q todos so variveis/identificadores int a = 0, b = 1, c; c = a + b; Double x = 5.298450; Quadrado q = new Quadrado(2); //nome uma varivei ou parmetro Pessoa.setNome(String nome);
Nota: a mesma regra bsica de nomenclatura de variveis vale para os nomes de mtodos, classes etc. A linguagem Java define que um identificador vlido caso inicie com uma letra ou o smbolo $, ou o smbolo _, sendo que esses dois ltimos no so recomendados. O tamanho do identificador virtualmente ilimitado, podendo ser composto por letras, nmeros, $ e _.
Escopo
As variveis e declaraes feitas dentro de um bloco s sero visveis dentro do mesmo bloco. Os objetos tenham sido alocados dentro de um bloco sero marcado para ser coletados ao fim do bloco caso no haja uma referncia externa para o mesmo. Ex.:
...{//bloco 1 int a = 5; Numero num1 = new Numero(5); Numero num2; {//bloco annimo int b = 5 * a; //o valor de b do bloco2 25 num2 = new Numero(5 * num1);//num2 um novo objeto Numero num3 = new Numero(num2); } int c = 2 * b; //Erro: b do bloco annimo no existe mais System.out.println(num2+num3) //Erro: num3 no existe }
www.abutua.com
Cursos Abtua
25
Caso um bloco interno (annimo ou no) declare uma varivel com o mesmo nome de outra varivel do bloco externo, o compilador ir emitir um erro de nome de varivel local duplicado. Ex.:
...{//bloco 1 int a = 5; if(true){//bloco 2 int a = 7; // Erro: varivel local duplicada int b = 5 * a; } } int c = 2 * b; //b do bloco2 no existe no bloco1
Os mtodos de uma classe podem declarar variveis e argumentos com os mesmos nomes dos campos da classe. Nesse caso as variveis e argumentos dos mtodos iro ocultar (tero precedncia) sobre os campos da classe. Ex.:
public class Bar{ //bloco da classe private int a = 3; public Bar() { //bloco do construtor int a = 5; //Bar.a ficou oculto Foo b = new Foo(); //O escopo de b o bloco do construtor System.out.println(a);//imprime 5 }//b foi destrudo aqui public void g() { //bloco do mtodo g System.out.println(a); //imprime 3 System.out.println(b); //Erro, no existe b neste escopo } }
Funes, Mtodos ou Procedimentos

So sequncias de declaraes que executam alguma tarefa determinada, ou algortimos. Uma funo pode possuir um valor de retorno, cujo tipo deve ser declarado no incio. Um nome pelo qual possa ser chamada. E argumentos. ( )
Caso a funo no retorne nenhum valor, o tipo de retorno deve ser void. Caso a funo retorne um valor alm do tipo do retorno no incio da funo, ser necessrio haver uma declarao return antes do fim do bloco. Caso no haja argumentos, estes podem completamente omitidos. Mas os parnteses devem ser mantidos. Uma a funo com modificadores, declarada em uma classe, chamada de mtodo. Nota: Quando um mtodo possui o atributo static, ele chamado de mtodo de classe (e no mtodo do objeto).
www.abutua.com
Cursos Abtua Exemplos:
26
//uma funo completa int incrementaDe(int valor, int incremento) { return valor + incremento; } //uma funo sem valor de retorno void imprimeDados(Pessoa p) { System.out.println(p.nome); System.out.println(p.sobreNome); } //uma funo sem parmetros Circulo criaCirculo() { return new Circulo(14.4); }
Operador this
Podem ocorrer casos em que um argumento ou uma varivel, declarada no mtodo, possua o mesmo nome de um campo declarado na classe (campo do objeto). Para resolver esses casos de ambiguidade a linguagem fornece o operador this. O operador this significa uma referncia para o prprio objeto. Utilizado em conjunto com o operador ponto possvel referenciar campos e mtodos do objeto. Ex. :
public class Pessoa { private String nome; public Pessoa(String nome) { this.nome = nome;//this torna visvel o campo nome que //estava oculto pelo parmetro nome } }
O operador this tambm torna possvel que um objeto passe ele mesmo como parmetro de um mtodo. Nota: A desambiguao de referncia para campos e mtodos estticos deve ser feita por qualificao, ou seja, com o operador ponto e o nome da classe. Ex.: Foo.bar()
Passagem por Valor e passagem por referncia

Na linguagem Java todos os parmetros so passados por valor, ou seja, so copiados do original e passados como argumento para o mtodo chamado. As variveis e parmetros para objetos so uma referncia para um objeto na JVM, ou seja, o mtodo chamado recebe uma cpia do endereo da memria aonde esse objeto realmente se encontra, e no uma copia do objeto. Por isso o objeto em si no pode ser alterado (trocado por outro objeto, por exemplo), mas seu contedo pode ser alterado. Ex.:
... Quadrado q = new Quadrado(2); int valor = calculaArea(q) ...
www.abutua.com
Cursos Abtua
27
public int calculaArea(Quadrado q2) { q2.setLado(5); //OK, permitido alterar o contedo q2 = new Quadrado(5); //q2 possui um novo objeto q2.setLado(25); //q2 no mais aponta para q } int l1 = q.getLado(); //retorna 5
Sendo a passagem por valor, o objeto original no afetado por um operador new, como exemplificado anteriormente. Tambm no possvel criar objetos atravs dos parmetros, ou seja, no possvel passar um argumento null e esperar que, ao final do mtodo, ele seja no nulo. Ex.:
Quadrado { Void criarQuadrado(Quadrado q) { q = new Quadrado(5); } ... Quadrado q = null; Quadrado.criarQuadrado(q); ... //q continua sendo nulo
www.abutua.com
Cursos Abtua
28
Mdulo 3 Captulo 7
Tipos de Dados
Tipos Primitivos ou Bsicos

Toda linguagem de programao oferece alguma forma de lidar com os tipos de dados mais bsicos. Esses dados normalmente so de natureza matemtica (nmeros), lgebra booleana (verdadeiro/falso) e textos. Ateno: importante ressaltar que os tipos primitivos, ou bsicos, no so objetos. Eles no so criados com o operador new e no podem assumir o valor nulo (null).
Inteiros e Ponto Flutuante

Os tipos para manipulao de nmeros possuem duas naturezas, os nmeros inteiros e os nmeros de ponto flutuante (decimais). Ambos podendo ser positivos ou negativos. Inteiros Devido a limitaes dos dispositivos computacionais (hardware), no possvel representar todos os nmeros existentes. Deve-se escolher o tipo com a faixa de valores mais apropriada para o clculo que se deseja trabalhar. Os tipos para representar nmeros inteiros esto divididos em faixas: Faixa Limite
-128 -32.768 -2.147.483.648 -9.223.372.036.854.775.808 a a a a +127 +32.767 +2.147.483.647 +9.223.372.036.854.775.807
Nome do Tipo
byte short int long
O compilador Java determina automaticamente o tipo para o valor digitado, se ele for to tipo inteiro. Inicialmente todos os valores so considerados int, caso o valor exceda os limites de int automaticamente ser tratado como long. Durante a atribuio, se o tipo da varivel for byte ou short, e o valor estiver dentro do limite do tipo declarado da varivel o valor ser convertido automaticamente. Caso contrrio, o compilador ir emitir um aviso/erro de truncamento de valor (perda de preciso). Ex.:
int a = 32; //OK tipo do valor int e varivel int byte b = 32; //OK tipo do valor int mas esta dentro da faixa de byte short c = 55000; //Aviso o valor ser truncado para 32767
Quando um valor est dentro da faixa de int, mase se deseja informa-lo como long, possvel indicar isso explicitamente acrescentando-se o ps-fixo l/L (quando o valor estiver alm da faixa de int o uso do ps-fixo obrigatrio). Ex.:
www.abutua.com
Cursos Abtua
long k = 3480L;
29
Tmabm possvel expressar os valores inteiros em bases diferentes da decimal. Para escrever um valor em base hexadecimal basta acrescentar o prefixo 0x, para descrever um valor em base binria (Java 7) utilize o prefixo 0b. Ex.:
int serial = 0xFA; // = 250 em base decimal int cartao = 0b1011111; // = 95 em base decimal
Ponto Flutuante Quando existe a necessidade de se trabalhar com valores decimais no lineares ou representar situaes como +, ou uma diviso por zero (NaN, not-a-number), foi desenvolvido a norma IEEE-754 que especifica os tipos de Ponto Flutuante. Os nmeros de ponto flutuante servem para representar valores decimais arbitrrios como: 0,25 () 1.130.437,0033748 0,000005 (510-6)
Apesar de ser possvel representar uma gama muito maior de valores, necessrio escolher um tipo de ponto flutuante com a preciso, em bits, mais adequada para armazenar o valor. Preciso (total) 32 bits 64 bits Nome do Tipo Float Double
A notao matemtica utilizada pelo Java (e pela maioria das linguagens de programao) para valores decimais utilizar . (ponto) para separar a parte inteira da parte fracionria e sem smbolo para separar os milhares. possvel descrever valores em notao cientfica utilizando-se e/E para simbolizar a base 10. Ex.:
double d = 2.2e+3; //o mesmo que 2200 ou 2,2103
possvel indicar a preciso desejada para valores decimais acrescentando-se um ps-fixo, f/F para float, e d/D para double. Ex.:
float angulo = 33.45f;
Por padro todos os valores de ponto flutuante, sem um ps-fixo, so considerados double.
double PI = 3.1415926535;
O compilador Java emitir aviso/erro sobre perda de preciso ao se atribuir um valor double a uma varivel float.
float PI = 3.1415926535;//Aviso! Perda de preciso
www.abutua.com
Cursos Abtua
30
Os valores NaN, infinito positivo e negativo esto disponveis atravs de campos estticos das classes Double e Float para serem atribudos aos tipos double e float respectivamente. Ateno: Valores inteiros podem ser atribudos em variveis do tipo float ou double, mas a converso de inteiro para ponto flutuante nem sempre ser exata, devido a forma de representao interna dos valores em ponto flutuante. Recentemente, na verso 1.7 da linguagem Java, possvel utilizar _ para separar conjuntos de valores para facilitar a leitura. Ex.: 1_352_42 o mesmo que 1352425, 0xA1_B6_C5
o mesmo que 0xA1B6c5, 3___2 o mesmo que 32.
Apenas permitido usar _ entre dgitos, quantos forem. Utilizar _ contiguo ao separador decimal ou ao prefixo/ps-fixo e no incio ou no fim da declarao invlido. Ex.: _1 um identificador (varivel) no um valor, 12_ invlido, 0x_AB tambm invlido.
Boleano
A lgebra booleana baseia-se em dois valores: verdadeiro e falso. O tipo boolean representa exatamente esses valores: true e false, respectivamente. Ex.:
boolean ligado = false;
Nota: Na linguagem Java no h converso entre Inteiros e Booleanos (interpretao de zero como false e no zero como true). Caso seja necessrio confirmar se um valor zero em uma expresso lgica, deve-se fazer a comparao explcita, ex.: if(pressao == 0)
Caractere
Os elementos mnimos de um texto (Strings em Java) so os caracteres. Esses caracteres so representados pelo tipo char (abreviao de caractere em ingls). Existem, no entanto, diversas lnguas escritas pelo Homem, cada qual com seu conjunto peculiar de smbolos. A linguagem Java segue o padro de codificao UNICODE que descreve mais de 100.000 caracteres diferentes. Internamente, na memria, o Java Utiliza UTF-16 (16bits por char) para a representao binria dos cdigos UNICODE. As operaes de leitura e escrita em fluxos de bytes (ex.: serializao) utilizam por padro o UTF-88, que mais compatvel com outros sistemas. Nota: Para o desenvolvimento de aplicaes com suporte internacional, importante lembrar que a linguagem Java oferece ferramentas para a converso de caracteres em diversos formatos de codificao. Deve-se tomar muito cuidado com o tipo char pois ele no pode representar smbolos complementares como um nico caractere, ou seja, smbolos que precisem de mais de 16bits.
Para a leitura e escrita de bytes utilizado o UTF-8, mas para o sistema de arquivos (java.io.File) utilizada a codificao nativa do sistema operacional, ex.: Latin-1.
www.abutua.com
Cursos Abtua
31
Os valores do tipo caractere devem ser, preferencialmente, escritos entre aspas simples ( ), mas so aceitos tambm valores inteiros, dentro da faixa de valores definida pelo UTF-16. Caracteres especiais devem ser precedidos de contrabarra, a letra u, e o cdigo hexadecimal dentro da faixa vlida UTF-16. Exemplos:
char char char char char x y z w k =A; //correto! um caractere = 123; //correto! Equivalente UNICODE para smbolo { = \u01A9; //correto! um atalho UNICODE para o smbolo = \t; //correto! um atalho para tabulao = h; //errado! Aspas so para Strings
www.abutua.com
Cursos Abtua
32
Mdulo 3 Captulo 8
Objetos e Alocao de Memria
Objetos
Do ponto de vista computacional os objetos so instncias de classes, ou espaos de memria alocados e gerenciados pela JVM, cujo layout definido por uma classe. Os objetos so referenciados, apontados, por uma ou mais variveis.
//As variveis x e y apontam para o mesmo objeto de Foo Foo x = new Foo(); Foo y = x; //Dado o mtodo void processa(Foo z) da classe Bar bar.processa(x);// z aponta para o mesmo objeto Foo de x e y
comum dizer que, de forma genrica, toda varivel que no for um tipo primitivo uma varivel de referncia. O espao de memria alocado armazena os valores dos campos alm possuir um indicador para o tipo que o descreve (campo esttico class) dentre outras.
Criando um objeto novo

A criao de um objeto envolve a Instanciao e Inicializao. Um objeto pode ser utilizado imediatamente aps sua inicializao ou, mais comum, ser atribudo uma varivel. Exemplo:
... public void tarefaExterna() { new Thread(getTarefa()).start(); }
A criao do objeto e sua atribuio uma varivel pode ser feita em uma nica declarao: declarada uma varivel, ela deve possuir um tipo, que a classe do objeto, e um identificador (ou nome). Imediatamente aps declarao da varivel segue o operador de atribuio. Durante a instanciao utiliza-se o operador new que instrui a JVM a alocar espao em memria suficiente para guardar um objeto de um tipo indicado aps o new. o Observao, o tipo da varivel e o tipo requisitado atravs do operador new devem ser iguais ou relacionados por herana. A inicializao consiste em atribuir valores aos parmetros do construtor e, depois, executar o mtodo construtor que iniciar a memria, processando os valores passados aos parmetros.
Ex.:
www.abutua.com
Cursos Abtua Quadrado q1 Declarao de uma varivel de nome q1 cujo tipo Quadrado
Preparatrio para Certificao Java = Atribuio do objeto criado ( direita) na varivel ( esquerda) new Quadrado Instanciao, a JVM aloca espao para um objeto do tipo Quadrado
33 (2); Inicializao, o valor 2 passado para o mtodo construtor da classe quadrado que atribui esse valor ao campo lado
O processo de criao de objetos pode ser escondido dentro de um mtodo da mesma ou de outra classe. Essa prtica denominada de mtodo fbrica. Ex.: Quadrado q2 = Utilidades.criarQuadrado(2); //aonde: Quadrado criarQuadrado(int lado) { return new Quadrado(lado); } Como os objetos so espaos de memria eles podem ser referenciados por diversas variveis e campos de outros objetos. Quando no existir mais nenhuma referncia para um objeto, ele coletado pelo Garbage Collector, ou seja, o espao de memria liberado e volta para o conjunto de memria livre.
Ancestral Comum
Em Java todos os objetos criados descendem de um ancestral comum, a classe Object. Essa classe prov acesso a campos e mtodos bsicos que so comuns para todos os objetos gerenciados pela JVM. Ex.: Todos os descentes de Object possuem um mtodo chamado toString(). Ele descreve de forma textual o tipo do objeto e o local da instncia (endereo de memria em hexadecimal precedido de @).
//Imprime algo similar a:
System.out.println(q1.toString());
org.exemplo.Quadrado@0xFF04A200
Enumerao
Enumeradores so um conjunto de valores nicos e ordenados, sendo que cada valor possui um nome prprio. Por exemplo: Um conjunto de formas geomtricas ordenadas pelo nmero de lados: (tringulo, quadrado, pentgono, hexgono).
Na linguagem Java os enumeradores so objetos especiais chamados de imutveis. Objetos imutveis no necessitam do operador new, pois seus valores so fixados durante a compilao e no mudam durante toda a execuo da aplicao. Para se declarar um tipo que seja um enumerador, deve-se utilizar a palavra chave enum seguida de um nome e os valores, separados por vrgula e entre chaves. Ex.:
public enum Poligonos {triangulo, quadrado, pentgono, hexgono}
www.abutua.com
Cursos Abtua
34
A declarao de uma varivel do tipo enumerador segue o mesmo padro de declarao de qualquer varivel: <tipo> <identificador>;
Poligonos p;
Para acessar os valores do conjunto utiliza-se o operador ponto (.):

p = Poligonos.quadrado;
Mtodos de Enum
Como os enumeradores so objeto eles possuem campos e mtodos, por exemplo: para se obter todos os valores do conjunto utilize o mtodo values(), para obter uma String com o nome do valor utilize o mtodo name(). Ex.:
for(Poligonos p: Poligonos.values()) { System.out.println(p.name());//imprime triangulo, ... }
Enumeradores como o do exemplo anterior possuem associados aos nomes, um valor numrico. Esse valor numrico pode ser declarado pelo programador para cada elemento, ou podem receber um valor numrico padro. O valor numrico padro corresponde posio do valor dentro da enumerao, comeando de zero e aumentando de 1 a cada elemento. Para se obter esse valor numrico utilize o mtodo ordinal(). Ex.:
System.out.println(Poligono.quadrado.ordinal());//imprime: 1
Enums avanados
Os enumeradores tambm podem ser complexos. Neste caso, a declarao do enumerador assemelha-se ao de uma classe com campos, mtodos e construtores. A diferena est nos mltiplos parmetros, acrescentados aps cada valor, eles sero utilizados pelo construtor. necessrio terminar a enumerao com ponto-e-vrgula (;) aps o ltimo valor antes de acrescentar os campos e mtodos. Nota: Para no ferir o princpio de imutabilidade, os campos devem ser imutveis, ou seja, sem mtodos set e o construtor oculto. Ex.:
public enum Heroi { guerreiro (20, 10, 5), guardiao (5, 20, 10), arqueiro (10, 5, 15); //campos imutveis(modificador: final) private final int ataque; private final int defesa; private final int mobilidade; //construtor protegido/oculto Heroi(int at, int df, int mb) { ... } //gets para os campos ...
www.abutua.com
Cursos Abtua
35
//mtodos adicionais public boolean atacar(Heroi alvo) { return alvo.defesa < this.ataque; } ... }
Arrays
Os arrays em programao so uma forma bsica de representar um agrupamento contnuo, de tamanho determinado e do mesmo tipo. Nota: Em Java os arrays so objetos, mesmo que seja um array para um tipo primitivo. Para se declarar uma varivel como array usa-se colchetes ([, ]) aps o tipo (preferencialmente). Para instanciar uma array deve-se indicar o seu tamanho (nmero de elementos). Ex.:
int[] x = new int[32]; //cria um array de 32 inteiros Quadrado[] b = new Quadrados[5]; //cria um array para 5 objetos do tipo Quadrado //no est errado, mas contra o estilo Sensor sensores[] = new Sensor[10];
possvel instanciar um array e j atribuir o seu contedo, basta colocar os valores entre chaves aps o operador de atribuio. O tipo do objeto array que ser criado deduzido implicitamente pelos valores entre as chaves. Ex.:
int[] x = {10, 20, 30, 40, 50}; //cria um array de 5 inteiros
Observao: possvel indicar explicitamente o tipo do objeto array que ser criado, utilize o operador new antes das chaves. Ex.:
int[] tons = new int[] {0x11, 0x55, 0xAA, 0xEE}; //vlido
Nota: Uma vez indicado o tamanho de uma array esse valor fixo.
Acessando os Elementos por ndices

Cada item de uma array chamado de elemento (element). Cada elemento de um array pode ser acessado pelo seu ndice, ou seja, sua posio dentro do array, comeando pelo ndice zero (0). Para acessar um elemento o ndice deve ser passado como parmetro do operador [] (colchetes) aps o nome da varivel:
//Dado int[] x = {10, 20, 30, 40};
Elemento 10 20 30 40 ndice 0 1 2 3
int a = x[2]; //valor de a ser 30
www.abutua.com
Cursos Abtua
36
Durante a instanciao, a JVM reserva espao suficiente para guardar a quantidade de elementos indicada. Para tipos primitivos, todos os elementos so inicializados para um valor padro (zero). Para tipos no primitivos (objetos), so reservados espaos para guardar referncias para objetos, tendo o valor inicial nulo (null).
int[] x = valor 0 x[0] = 10; x[1] = 20; x[2] = 30; x[3] = 40; new int[4]; //cria um array de 4 inteiros, todos com //troca //troca //troca //troca o o o o valor valor valor valor 10 20 30 40 no no no no ndice ndice ndice ndice 0 1 2 3
Quadrado[] q = new Quadrado[2]; // cria um array de referncias para 2 objetos, ambos com valor inicial null //troca o valor no ndice 1 de null para um novo objeto q[1] = new Quadrado(2); boolean b1 = (q[0] == null); // true boolean b2 = (q[1] == null); // false
Como qualquer objeto, um array oferece campos e mtodos. Por exemplo, para saber o tamanho de um array acesse o campo length. Ex.:
int tam = x.length //x recebe o valor 4
Array Multidimensional
possvel criar arrays multidimensionais, basta que o tipo venha acompanhado de dois ou mais pares de colchetes. Ex.:
float[][] m = new float[3][4]; //cria um array de duas dimenses, ou uma matriz
Lembrando que em Java arrays so objetos e, portanto, arrays multidimensionais so arrays de objetos que apontam para arrays de objetos. possvel criar arrays multidimensionais de tamanhos variveis. Ex.:
byte[][] v = { {1, 2, 3}, {4}, {6, 7} }; // equivalente a: byte[][] v v[0] = new v[1] = new v[2] = new = new byte[3][]; byte[] {1, 2, 3}; byte[] {4}; byte[] {6, 7};
Note que na segunda forma do exemplo anterior: 1) necessrio explicitar o tipo das arrays 2) Deve-se explicitar o tamanho da dimenso mais externa.
As regras de arrays de uma dimenso tambm se aplicam para arrays multidimensionais. Ex.: www.abutua.com
Cursos Abtua
37
//dado m := {{1, 2}, {3, 4}, {5,6}} float[] linha = m[0]; // linha := {1, 2} float g = m[2][1]; // g := 6
Ateno! Arrays em Java so objetos, portando ao se fazer uma atribuio o que ser copiada a referncia ao objeto e no o objeto! Ex.:
int[] a = new int[10]; int[] b = a;//b no uma cpia! aponta para o mesmo objeto de a
Copiando Arrays
Para se copiar efetivamente uma array necessrio percorrer e copiar manualmente cada elemento, ou utilizar o mtodo de sistema System.arraycopy(). Esse mtodo possui a facilidade de permitir a cpia completa ou parcial dos elementos de uma array simples. So necessrio os parmetros: Array de origem, posio inicial na origem, Array de destino, posio inicial no destino e quantidade de elementos que sero copiados. Ex.:
int[]a = {1, 2, 3, 4, 5}; int[]b, c; //copiando manualmente b = new int[a.length]; //b tera mesmo tamanho de a for(int idx = 0; idx < b.length; ++idx) { b[idx] = a[idx]; //vlido para tipos primitivos } //Copiando com arraycopy c = new int[2]; System.arraycopy(a, 1, c, 0, c.length);//c := {2, 3}
Mas copiar um array de objetos exige operao manual.
Strings
Apesar de ser possvel criar arrays do tipo char, a linguagem Java possui um objeto mais apropriado para a manipulao de palavras e frases que a classe String. As Strings so objetos imutveis, no necessitam do operador new para se criar um objeto desse tipo. Caso se queira construir uma string a partir de outro objeto como, por exemplo, um array de char, ou se quiser ter cpias distintas do mesmo texto, torna-se necessrio o uso do operador new. Para se criar um objeto do tipo String basta indicar o texto entre aspas (). Ex.:
String nome = Joao; String letra_A = A; String greeting = Ol mundo da programao orientada a objetos em Java!;
Uma String pode ser construda atravs de uma array de letras (char[]). Ex.:
char[] x = {J,o,a,o};
www.abutua.com
Cursos Abtua
38
String nome = new String(x); //nome := Joao
Uma String pode ser vazia ou, como todo objeto, uma pode ser nula.
String nome = null String nome = ; //Objeto String nulo //String vazia
Dica: o mtodo isEmpty() retorna true em caso do objeto String existir mas estar vazio.
Manipuladores de String
Operador mais (+) As Strings podem ser concatenadas utilizando-se o operador +. Ex.:
String nomeCompleto = Joao + Charles; // nomeCompleto := Joao Charles
charAt Retorna o caractere na posio requisitada, similar ao operador [] das arrays e, assim como ele, emite um erro (tanto em compilao quanto em execuo) se for requisitado um ndice fora dos limites do tamanho da String. Ex.:
String s = O rato roeu a roupa do rei de Roma; char c = s.charAt(5); // o o quinto smbolo/caractere dentro da String; char d = s.charAt(99);// Erro: ndice fora dos limites
indexOf Retorna o valor do ndice (a posio) da primeira ocorrncia de um caractere ou de uma palavra dentro de uma String. Retorna -1 caso no consiga encontrar a letra/palavra. Ex.:
s.indexOf(r); //retorna o valor 2 s.indexOf(roupa); //retorna o valor 14 s.indexOf(W); //retorna -1
O mtodo tambm aceita procurar a letra ou palavra a partir de um ponto inicial. Ex.:
s.indexOf(r, 15); //retorna o valor 23
trim Aps a requisio de valores comum remover qualquer smbolo vazio (como espao e tabulaes) antes do processamento. O mtodo trim remove esses smbolos do comeo e do fim da String. Ex.:
// tabulao = \t, espaos em brando = , quebra de linha = \n, caractere nulo \0 String w = \t \0Ola Mundo\n\n \0; String x = w.trim; //x := Ola mundo
substring Similar ao mtodo de sistema arraycopy. Dados o ndice inicial e um ndice final, retorna uma nova String contendo apenas os caracteres do trecho requisitado. Ex.:
www.abutua.com
Cursos Abtua
39
String s = O rato roeu a roupa do rei de Roma; int inicio = s.indexOf(roupa); String sub = s.substring(inicio, inicio + 12); //sub := roupa do rei
Caso no seja indicado o ndice de fim, substring retornar todo o texto comeando pelo ndice indicado at o fim da String.
String sub = s.substring(30); //sub := Roma
Caso o ndice inicial ou o final estejam for a dos limites da String ser emitido um erro. replace Substitui todas as ocorrncias de um caractere ou caracteres (palavra) em uma String por outro caractere ou caracteres. Exemplo:
String sub = s.replace(r, \u01A9); //sub := O ato oeu a oupa do ei de Roma Sub = s.replace(ro, LA); //sub := O rato LAeu a LAupa do rei de Roma
length Retorna o tamanho total da String. Ex.:

int i = s.length(); //i := 34
startsWith e endsWith Retornam um booleano indicando se a String comea ou termina com a substring indicada. Ex.:
boolean x = s.startsWith(r); //false, a String comea com O boolean y = s.endsWith(Roma);//true, a String termina com Roma
Tamanho mximo de Arrays e Strings

O maior tamanho de um array ou de uma String em Java corresponde ao maior ndice que pode ser acessado, como os ndices so valores do tipo int e no podem ser negativos, o maior tamanho, terico, de um array 231 ou 2.147.483.648 elementos. Como o valor mximo em bytes pode exceder 2GiB, o limite fsico da quantidade de elementos de um array est limitado pelo sistema nativo.
www.abutua.com
Cursos Abtua
40
Mdulo 4 Captulo 9
Lgica e Declaraes
Operadores de Atribuio
Ao longo dos exemplos anteriores possvel observar que um dos smbolos mais utilizados o = (igual). Esse smbolo representa uma operao de atribuio explcita. Uma atribuio a operao que faz a ligao entre uma varivel e um objeto, ou entre varivel e um valor (para os de tipos primitivos). Durante a atribuio o compilador ir verificar se os tipos da varivel e do objeto/valor esto corretos, e informar com avisos e erros em casos de perda de preciso, problemas de herana, tipos incompatveis etc. Durante a execuo tambm podem ocorrer problemas de atribuio que no podem ser identificados durante a compilao. Ex.:
//Atribui o valor 2 a varivel com identificada como i int i = 2; //Aviso de perda de preciso na compilao (int > short) short j = 50000; //Para: getPeso() retorna int //Erro: String e int no so compatveis String k = obj.getPeso(); //Erro: o retorno de um mtodo sempre um valor obj.getPeso() = 55;
Nota: Os elementos de um array acessados atravs do operador [] so aptos para atribuio, similarmente ao acesso dos campos de um objeto Ex.:
int[] e = new int[2]; e[0] = 55 //Correto, atribui o valor 55 ao elemento 0 do array public class Especial { public int flocoDeNeve; } Especial e = new Especial(); e.flocoDeNeve = 100;//Correto, atribui o valor 100 ao campo
Operadores de atribuio compostos

Os operadores de atribuio compostos servem para agilizar tarefas rotineiras como a de acumular um valor em uma varivel. Basicamente eles sintetizam a tarefa: De Varivel = Varivel {operao} Valor para Varivel {operao}= Valor Podendo Valor ser o resultado de uma expresso.
www.abutua.com
Cursos Abtua Atribuio com soma (+=)
41
int a = 0; a += 2; // o equivalente de: a = a + 2;
Atribuio com subtrao (-=)

int b = 10; b -= 5; // o equivalente de: b = b - 5;
Atribuio com multiplicao (*=)

int c = 2; c *= 8 - 3; // o equivalente de: c = c * (8 3);
Atribuio com diviso (/=)

double d = 10.0; d /= 2.0 * 3.0; // o equivalente de: d = d / (2.0 * 3.0);
Operadores Lgicos Relacionais

Os operadores lgicos relacionais relacionam duas variveis ou expresses, comparando alguma grandeza e retornando um booleano apropriado para a operao de comparao requisitada. Os tipos dessas variveis devem ser comparveis. Todos os tipos primitivos so comparveis entre si naturalmente, pela grandeza de seu valor. Os objetos so comparados entre si pelo valor de sua posio na memria, a menos que seja fornecido um mtodo alternativo de comparao.
Os operadores de comparao so:
Menor que (<)

boolean menor = 3.2 < 5.0; //true, 3.2 menor que 5.0
Menor ou igual a (<=)

if(3 <= 3) {... //true, 3 menor ou igual a 3
Maior que (>)

float[] a = {0.3, 0.2, 0.1}; int[] b = {55, 99}; a.length > b.length; //true, a (length: 3) maior que b (length: 2)
www.abutua.com
Cursos Abtua
42
Maior ou igual a (>=)

a.length >= (5 * 2.0) //false, 3 menor que 10.0
Igualdade (==)
String s = macarro; getMacarrao() {return macarro;} s == getMacarro();//true, os endereos so iguais9
Diferente (!=)
Quadrado q; boolean result = s.isEmpty() != false; retorna true e true diferente de false //true, s.isEmpty()
Operadores Matemticos
Todas as variveis dos tipos primitivos inteiros e de ponto flutuante (e seus equivalentes em objetos, ex.: Integer, Double), podem ser utilizados para clculos matemticos nas quatro operaes bsicas: soma (+), subtrao (-), multiplicao (*) e diviso (/). As operaes matemticas podem ser compostas durante uma declarao. Entre os operadores matemticos, a ordem de execuo da esquerda para a direita, com maior para menor precedncia: multiplicao, diviso, mdulo, soma e subtrao.
int a = 1000000 323455 + 255 * 323; float b = 4.0f * 5.25f + 2.75f;
sempre recomendvel, e uma boa prtica de programao, separar os conjuntos de operaes com parnteses.
int a = ((1000000 323455) + 255) * 323; float b = (4.0f * 5.25f) + 2.75f;
Notas: Caso o clculo misture ponto flutuante e inteiro, os tipos inteiros sero automaticamente promovidos para ponto flutuante. A linguagem Java no possibilita a sobrecarga de operadores. Excepcionalmente os objetos da classe Strings podem utilizar o operador soma (+) como operador de concatenao entre Strings. No entanto seu uso desaconselhado. Recomenda-se o uso do mtodo concat. Ao utilizar o operador soma entre Strings e tipos primitivos faz com que os mesmos sejam convertidos para sua representao textual. Ex.: valor + 2 valor 2. Ao utilizar o operador soma entre Strings e outros objetos faz com que o mtodo toString sejam chamados nesses outros. Ex.: Foo + foo Foo + foo.toString().
9
A menos que seja utilizado o operador new, o compilador cria uma tabela de consulta (pool) para evitar duplicao de Strings. Assim, todas as strings sintaticamente iguais possuem o mesmo endereo.
www.abutua.com
Cursos Abtua
43
Diviso inteira
Para os valores de tipo inteiro, a diviso composta por dividendo, divisor, quociente e resto:
O quociente, ou resultado, obtido pelo operador diviso (/) O resto, ou remainder, obtido pelo operador mdulo (%)
Exemplo:
int a = 5, b = 2, c, d; c = a / b; //c possui o valor 2 pois a parte inteira da diviso ( ) d = a % b; //d possui o valor 1 pois o que falta para completar 5 em ( )
Operadores Unrios
As operaes incremento de um e decremento de um, so muito comuns em programao, algumas vezes possuindo at instrues especiais em hardware para sua execuo. Em vez de escrever i = i + 1 ou i += 1, possvel utilizar o operadore unrio de incremento. O nome unrio se deve ao fato dele operar sobre uma nica varivel, ao contrrio dos outros operadores que agem sobre um par de variveis. Os operadores unrios so sensveis ao posicionamento, isto , mudam a semntica conforme o contexto: Pr-fixo:
int i = 5, a; a = ++i; //primeiro incrementa i e atribui o resultado em a (6)
Ps-fixo:
int i = 0, a; a = i--; //primeiro decrementa i (-1) atribui o valor de i em a (0), depois
Nota: A linguagem Java permite a utilizao de incremento e decremento com variveis de ponto-flutuante. Nesse caso, o operador ++ comporta-se como += 1.0
Operadores lgicos
Os operadores lgicos so utilizados para efetuar matemtica booleana. Esta define as operaes bsicas:
www.abutua.com
Cursos Abtua
44
E (&&)
Dada a tabela da verdade: A true true false false B true false true false A&&B True false false false
O resultado de A&&B ser verdadeiro apenas quando ambos, A e B, tambm forem verdadeiros.
int a = 5, b = 3; String s = ; ((a - b) == 2) && s.isEmpty() // a expresso resulta em true
Ou (||)
Dada a tabela da verdade: A true true false false B true false true false A||B true true true false
O resultado de AIIB ser falso apenas quando ambos, A e B, tambm forem falsos.
while ((inercia > 0) || (forcaExterna)) {carro.deslocar(...);...} // enquanto houver inrcia ou uma fora externa estiver agindo, o objeto carro se desloca, se no houver ambos, o carro para
Negao (!)
Dada a tabela da verdade: A !A true False false True
O resultado de !A ser falso quando A for verdadeiro. O resultado de !A ser verdadeiro quando A for falso.
if(!isChovendo()) { lavaCarro();} //se no estiver chovendo, lavar o carro
www.abutua.com
Cursos Abtua
45
Mdulo 4 Captulo 10
Expresses Condicionais, Controle de fluxo
As expresses condicionais direcionam o fluxo de execuo do programa, elas expressam as aes que devem ser tomadas mediante os determinados valores de variveis ou expresses. As expresses condicionais podem ser compostas umas nas outras, de forma a poder expressar a lgica desejada, por mais complexa que seja. Ex.:
if(...) { while(...) {...} } else { if (...) { for() {...} } }
if - else
O condicional if executa o bloco de cdigo associado caso a expresso lgica entre parnteses resulte em verdadeiro, caso contrrio ele continua com o cdigo aps o bloco associado.Ex.:
if(velocidade > 100) { ... setAcelerar(false);//bloco associado ... } //execuo normal ... verificaRetrovisor(); leOdometro();
O condicional if-else executa o bloco de cdigo associado ao if caso a expresso lgica entre parnteses resulte em verdadeiro, caso contrrio ele executar o bloco associado ao else.
if(velocidade > 100) { ... setAcelerar(false);//bloco associado if ... } else { ... setAcelerar(true);//bloco associado else ... } //execuo nomral verificaRetrovisor(); leOdometro();
Para os if-else aninhados, o primeiro else corresponder ao ltimo if (o mais interno), assim como o sengundo else ao penltimo if, assim por diante. Para melhorar a legibilidade do cdigo recomendvel utilizar sempre blocos e indentao (espaos progressivos para representar o nvel do cdigo).
www.abutua.com
Cursos Abtua
46
//sem indentao, sem blocos: compreenso fica prejudicada if(condicaoA) //primeiro if(condicaoB) //segundo dentro do primeiro declaracao.ouMetodo(); else //pertence ao segundo declaracao.ouMetodo(); // //Com indentao, com blocos: melhora a legibilidade if(condicaoA) { if(condicaoB) { declaracao.ouMetodo(); } else { declaracao.ouMetodo(); } }
Dica: As expresses if-else podem ser utilizadas seja qual for o grau de complexidade para a expresso lgica, mas principalmente para executar testes de faixas de valores.
switch-case
O condicional switch serve para testar um valor inteiro, ou o valor de uma enumerao, contra uma srie de valores possveis (casos). A partir da verso 1.7 da linguagem Java, o condicional switch tambm aceita Strings como valor para comparao. Cada caso a ser testado possui a sintaxe: case <valor a ser testado>: <expresses>*[break;] Quando um caso combina, ou seja, quando o valor do caso for igual ao valor do switch, todas as expresses do caso combinado sero executadas, incluindo as expresses dos prximos casos, at que se alcance um break ou o fim do switch. Nota: Os cases so testados em sequencia, mas seus valores no precisam estar em nenhum tipo de ordem. Ao final do switch pode ser acrescentado o caso especial default, sua sintaxe similar sintaxe de caso, mas no contm um valor para teste. O caso padro (default) ser executado quando nenhum outro caso combinar. Ex.:
//dado a como uma varivel int switch(a) { case 0: System.out.println(caso zero); break; case 1: System.out.print(caso ); System.out.println(um); break; case 2: System.out.print(caso dois e ); case 3: System.out.println(caso trs);
www.abutua.com
Cursos Abtua
47
break; default: System.out.println(nenhum dos casos); break; } //se //se //se //se //se a a a a a := := := := := 0 1 2 3 9 imprime imprime imprime imprime imprime caso zero caso um caso dois e caso trs caso trs nenhum dos casos
Dica: Switch faz comparaes estritamente de igualdade sendo mais indicado para valores pontuais, tambm possui a capacidade de executar expresses de outros casos (se fosse feito com if-else poderia resultar em duplicao de cdigo).
Operador ?
Para situaes de baixa complexidade, principalmente quando uma simples atribuio depende de uma condio, em vez de escrever uma declarao if-else completa, pode-se utilizar uma expresso com o operador ?. Sua sintaxe : (<condicio>)?<verdadeiro>:<falso> Dada uma <condio> o operador ? ir retornar resultado da expresso em <verdadeiro> quando a condio for true ou retornar o resultado da expresso em <falso> quando a condio for false.
//Se for menino o nome ser Marcelo se for menina ser Marcela int String nome = (bebe.getSexo()==M)?Marcelo:Marcela;
Nota: possvel aninhar uma expresso ? dentro das expresses <verdadeiro>:<falso>. No entanto esse estilo de cdigo desencorajado.
www.abutua.com
Cursos Abtua
48
Mdulo 4 Captulo 11
Laos
while
While representa a condio: enquanto. Inicialmente testada a expresso condicional, se ela resultar em verdadeiro o bloco associado executado e ao seu trmino volta para a expresso condicional. Quando a expresso condicional resultar em falso, a execuo pula para depois do bloco associado. recomendado quando se precisa repetir uma declarao ou bloco zero ou mais vezes. Ex.:
//Comer enquanto estiver com fome while(fome == true) { comer(); } dormir();
do while
Similar ao while, mas primeiro executa o bloco associado ao do antes de testar a expresso condicional. recomendado quando o se precisa repetir uma declarao ou bloco uma ou mais vezes. Ex.:
//imprime uma lista de opes at que uma delas seja escolhida int comando = 0; do { System.out.println(escolha: 1 para X; 2 para Y; 3 para sair); comando = lerComando(); }while((comando < 1) || (comando > 3));
for
Condicional utilizado para repetir uma expresso ou um bloco associado um determinado nmero de vezes. O for composto por: declarao, condio e incremento, separados por ponto-e-vrgula (;). for(declarao ; condio ; incremento) declarao: o pode-se declarar e iniciar uma ou mais variveis. Ex.: int i = 0; ou int i = 0, int j = 5; o pode-se referenciar e iniciar variveis declaradas externamente. Ex.: x = vetor.length; condio: o deve haver apenas uma, no importando a complexidade, deve resultar em um nico verdadeiro ou falso o enquanto resultar em verdadeiro, repete a execuo do bloco de declaraes
www.abutua.com
Cursos Abtua
49
incremento: o uma ou mais declaraes que alterem as variveis de condio o sempre executado aps o bloco de declaraes
As variveis da declarao, a condio e os incrementos no precisam ser necessariamente tipos primitivos. Podem ser utilizados variveis para objetos, desde que esses objetos forneam uma forma de navegao (incremento e condio de parada). Exemplos:
//para carros sendo um array //conta de 0 at o tamanho do array for(int i = 0; i < carros.length; ++i) { verificaMotor(carros[i]); } //para m sendo uma matriz 4x8 ou maior //percorre os elementos (0,0),(1,2),(2,4)e(3,6) for(int i = 0, j = 0; i < 4 && j < 8; ++i, j += 2) system.out.println(m[i][j])
Nota: declarao, condio e incremento podem ser omitidos. No caso da omisso da condio ou de omisso dos trs, o resultado ser um loop infinito. (for(;;){})
for each
Quando se necessita percorrer todos os elementos de uma coleo, ou de um array, recomendvel utilizar o condicional for com uma declarao simplificada. No condicional for-each declara-se apenas uma varivel que receber o elemento da coleo ou array seguido pela varivel da coleo ou array, separados por dois-pontos (:). Ex.:
//dado Carro[] carros = ... //percorre todos os objetos de carros usando c como referncia for(Carro c : carros){ verificaMotor(c); }
Iterator
Iterators so objetos que auxiliam na navegao de colees. Eles fornecem mtodos de controle, requisio e remoo dos elementos da coleo. Um exemplo de iterator com o loop while:
//dado lista com um Iterator para uma coleo de quadrados, //remover os quadrados com lado menor que 2 while(lista.hasNext()) { Quadrado q = lista.next(); if(q.getLado() < 2) { lista.remove(); } }
www.abutua.com
Cursos Abtua
50
hasNext Retorna um booleano. Quando verdadeiro, indica que possvel avanar para o prximo elemento da coleo. next Avana o objeto iterator e retorna o elemento da coleo (retorna um nulo se o iterator alcanou o fim da coleo). remove nica forma segura de se remover um elemento da coleo, enquanto o objeto iterator existir. Coleo ou array Coleo ou array
Iter.Next() Iterador Iterador.hasNext() := true Iterador Iterador.hasNext() := true
Quebrar e Continuar
Os laos podem ser terminados ou resumidos programaticamente, ou seja, por interveno programada. Para esse fim a linguagem Java expe duas palavras chaves: break: assim como em switch esse comando termina a execuo do loop devolvendo a execuo para o cdigo aps o bloco do lao
for(int i = 0; i < 10000; ++i) { if(i == 500) break;//termina o for em 500 ao invs de 9999 } outroCodigo(); ...
Label-break: O break original quebra apenas o lao mais interno, em caso de laos aninhados. Uma novidade, a partir da verso 1.5 da linguagem Java, torna possvel marcar (label) um lao externo e fazer com que o break volte para o lao nomeado.
marca_1: for(int x = 0; x < 10; x++) { for(int y = 0; y < 10; y++) { if(x+y = 14) break marca_1;// termina completamente o for } }
continue: faz com que a execuo volte para o teste de condio do for (ou while) como se o tivesse alcanado ao fim do bloco.
//Todos os empregados que no forem Executivos tero reajuste for(Empregados emp: empresa.getEmpredaos()) { if(emp.getCargo() == Cargo.Executivo) continue; reajusteSalaraio(0.05, emp); }
www.abutua.com
Cursos Abtua
51
Laos aninhados
Os laos podem ser combinados e aninhados uns dentro dos outros. Por exemplo, possvel ter mltiplos nveis de for para percorrer elementos como uma matriz multidimensional. No entanto este recurso deve ser utilizado com cuidado. Os loops aninhados aumentam consideravelmente o tempo de processamento e a complexidade do algoritmo.
www.abutua.com
Cursos Abtua
52
Mdulo 5 Captulo 12
Classes, Herana, Polimorfismo, Sobrescrita e Sobrecarga
Nos captulos 4 e 5 foram apresentados os conceitos de objetos, classes e modificadores de acesso. Neste mdulo sero abordados mais detalhes sobre as classes e suas relaes com outras classes.
Classes
Recapitulando, as classes na linguagem Java so declaradas em pacotes, sendo que cada classe corresponde a um arquivo e o pacote corresponde hierarquia de diretrios. Os modificadores de acesso (private, protected, package, public) alteram a visibilidade da classe e de seus membros. Outros modificadores tambm podem ser aplicados s classes com propsitos particulares.
Modificador Esttico
Static Class O modificador static quando aplicado a uma classe permite declarar uma classe dentro de uma classe (classes aninhadas). Os membros da classe externa tem acesso a todos os membros da classe interna, inclusive os privados. um recurso utilizado em alguns casos de aplicaes multithreads, ou para melhor organizar a lgica de um objeto, ou seja, quando um objeto s faz sentido como sub objeto do objeto que o declarou (ex.: EntryMap dentro de Map).
public class Lista { //Objeto interno N utilizado para fazer uma //rvore balanceada protected class No { private int peso; private Object prox; private Object conteudo; } private No[] arvore; ... //o objeto externo tem total acesso aos membros internos public void add(Object obj) { No n = new No(); n.peso = obj.hash(); n.proximo = getNoPesoMaiorQue(n.peso); n.conteudo = obj; adicinaNo(n); } //utilizador no precisa saber que existe a rvore public Object get(int posicao) { return No[posicao].conteudo; } }
www.abutua.com
Cursos Abtua
53
Iniciador Esttico Uma classe pode possuir um ou mais iniciadores estticos, ou blocos estticos, para iniciar os campos estticos de classe ou executar outras tarefas como configuraes da JVM, carregar uma biblioteca nativa etc. O nome bloco esttico vem do fato de ser declarado apenas como um bloco precedido da palavra static. Ex.:
public class ObjSeguro { static CharSequence chave; static { chave = unv48+pBQUa4iI7AaOWFctBD/YfIAFa0=; } }
Quando a classe carregada pelo ClassLoader da JVM o membro chave iniciado com o valor dado. Todos os objetos (instncias) de ObjSeguro compartilharo a mesma referncia para o valor. Nota: De uso raro, possvel declarar blocos iniciadores no estticos. Todos os blocos iniciadores no estticos so agrupados e copiados em todos os construtores do objeto. Mtodos e Campos Estticos Quando aplicado aos mtodos e campos torna-os membros da classe em vez do objeto. Todos os objetos (instncias da classe) compartilharo as mesmas referncias para os membros estticos. Notas: Uma conveno adotada para campos estticos que seus identificadores sejam todos em maisculo, similar s definies de macros de C. Apesar de ser possvel referenciar um membro esttico atravs de uma instncia com o operador ponto, essa forma no recomendada. O acesso aos membros estticos deve ser feita pelo nome da classe.
public class CodigoAntigo { public static int VALOR_1 = 1; public static int VALOR_2 = 22; public static void funcaoLegada(int valor) {} } ... CodigoAntigo old = new CodigoAntigo(); CodigoAntigo.funcaoLegada(CodigoAntigo. VALOR_1);//correto Old.funcaoLegada(old. VALOR_2);//Possvel mas imprprio
Os campos estticos devem ser iniciados, explicitamente como os campos de objetos ou, pelo bloco esttico ou, por mtodos estticos. Nota: Um erro bastante comum implementar mtodos estticos que tentam modificar campos ou acessar mtodos no estticos. Lembre-se sempre: membros no estticos pertencem ao objeto e, portanto, precisam de uma instncia para existir.
Modificador Final
O modificador final tem diferentes propsitos quando aplicados classe ou a seus membros.
www.abutua.com
Cursos Abtua
54
Final Class Quando aplicado classe indica que ela no pode ser herdada por nenhuma outra classe.
public final class Circulo { ... } //Erro a classe Crculo final public class Elipse extends Circulo { ... }
Final Mtodo Similar para quando aplicado a uma classe. Indica que o mtodo no pode ser sobrescrito, mas pode ser sobrecarregado.
public class ObjGeometrico { public final int calcArea() {...} } Public class Circulo { //Erro, calcArea final @Overrride public int calcArea() {...} }
Nota: Mtodos finais so seguros para serem chamados por construtores, pois garante que uma classe herdeira no ir modificar o mtodo, o que poderia levar a inconsistncias no sistema. Final em Variveis O modificador final pode ser aplicado a todos os tipos de variveis (escopo, classe, objeto e parmetros). Seu significado similar ao const de C/C++. Indica que o valor da varivel no mudar depois de atribudo. Quando aplicado aos campos do objeto (ou da classe), os mesmos devem ser iniciados diretamente na declarao ou no construtor.
public class Motor { public enum Combustivel {gas, alc, bi} private final Combustivel comb; public Motor() { comb = Combustivel.bi; } }
Herana de Classes
Herana a relao entre dois ou mais objetos. Quando o tipo de um objeto essencialmente do mesmo tipo de outro, apenas apresentando um comportamento extra ou diferente diz-se que a classe desse objeto herda a classe do outro objeto parente. Ex.: Uma canoa um barco, assim como uma lancha tambm um tipo de barco. Podemos dizer que barco o parente (ou ancestral) e que canoa e lancha so seus herdeiros. Ambos herdam
www.abutua.com
Cursos Abtua
55
as caractersticas de um barco, como formato base, capacidade de flutuar e se deslocar na gua, mas a canoa utiliza remos como propulso e a lancha um motor. Na linguagem Java a herana por classes uma herana simples, ou seja, uma classe herdeira apenas pode herdar de uma nica outra classe ancestral. A herana declarada atravs da palavra chave extends. A notao UML para classe e herana: Classe Pai
Classe Filha
Todos os objetos herdam implicitamente da classe Object. public class Funcionario equivalente a public class Funcionario extends Object o Funcionario Object
Como a linguagem suporta apenas herana simples, a classe que herdar Funcionario herdar Object indiretamente. public class Gerente extend Funcionario o GerenteFuncionario Object
Quando se usa herana com extend diz-se que uma relao um, ou seja: Funcionrio (implicitamente) um Objeto Gerente (explicitamente) um Funcionrio
Isto quer dizer que todos os membros de Funcionrio estaro presentes em Gerente mais os membros que forem declarados no ltimo. No entanto o inverso no verdadeiro, um Funcionrio no um Gerente. Por exemplo, se Gerente possuir o mtodo observarTrabalho, no ser possvel chamar esse mtodo atravs de Funcionrio.
public class Funcionario { private String nome; private Double Salario; ... } Public class Gerente extend Funcionario {
www.abutua.com
Cursos Abtua
56
Public void observaTrabalho(Funcionario f) {...} } ... Funcionario marcos = new Funcionario(); Funcionario joao = new Gerente(); //Erro mtodo observaTrabalho no existe em Funcionario joao.observaTrabalho(marcos);
InstanceOf
A linguagem Java possibilita inferir o verdadeiro tipo de um objeto referencia por uma varivel atravs do operador instanceof. <varivel> instanceof <Classe>: boolean Para o exemplo anterior, uma instncia de Gerente atribuda em uma varivel do tipo Funcionrio. Como Gerente um Funcionrio a atribuio ser completada sem erros. Ao se chamar o mtodo observarTrabalho() na varivel ocorrer um erro pois Funcionario no possui esse mtodo. Para saber se a varivel joao da classe Gerente deve ser feito:
if(joao instanceof Gerente) ((Gerente)joao).observaTrabalho(marcos);
Quando instanceof retorna true seguro converter (cast) a varivel para a classe questionada.
Polimorfismo
uma palavra grega para muitas formas. O polimorfismo pode ser atingido de duas formas: atravs da sobrecarga ou da sobrescrita.
Sobrecarga
J visto anteriormente que um mtodo possui: <modificadores> <tipo de retorno> nome(<parmetros>) {<declaraes>} Quando vrias declaraes de mtodos possuem o mesmo nome, mas um nmero varivel de parmetros (do mesmo tipo ou de tipos diferentes) ou mesmo que o tipo do retorno seja diferente, isso chamado de sobrecarga. comum que o construtor da classe seja um mtodo sobrecarregado.
//Exemplo println de System.out void println() void println(boolean x) void println(char x) void println(char[] x) void println(double x) void println(float x) void println(int x) void println(long x) void println(Object x) void println(String x)
www.abutua.com
Cursos Abtua
57
//Exemplo com construtores parciais public class Funcionario { private String nome; private double salario; private int horas; //construtor vazio delega para construtor de 3 argumentos public Funcionario() { this(, 0.0, 0); } public Funcionario(String nome, double salario, int horas) { this.nome = nome; this.salario = salrio; this.horas = horas } }
Nota: Uma classe filha tambm pode sobrecarregar os mtodos da classe pai, no entanto apenas os objetos da classe filha se beneficiaro das sobrecargas. Construtores, super e this Algumas notas sobre construtores Os construtores no so herdados. Se nenhum construtor for declarado, o compilador ir gerar um construtor sem argumentos automaticamente. Se pelo menos um construtor com argumentos for declarado o construtor sem argumentos deve ser declarado explicitamente. Os construtores das classes filhas podem se referir aos construtores da classe pai atravs do operador super seguido por uma lista de parmetros (super(<parametros>)). Os construtores podem referir-se a outros construtores da mesma classe atravs do operador this seguido por uma lista de parmetros (this(<parametros>)). Neste caso so chamados de construtores parciais. Caso no haja this ou super explcitos ser gerado um super() implcito. super() implcito ou super(<parametros>) explcitos devem e sero sempre a primeira declarao do construtor.
Ao executar a instanciao de um objeto a JVM segue um padro: 1. Aloca memria suficiente para armazenar o objeto 2. Inicia as variveis para seus valores padro (ex.: 0, 0.0, null) 3. Chama o construtor da classe compatvel com os argumentos fornecidos 3.1. Executa construtores parciais this(...), se houverem 3.2. Executa construtor super(...) explicito, se houverem 3.3. Executa construtor super() implcito 3.4. Executa o corpo do construtor 4. Repete 3 recursivamente at chegar em Object
www.abutua.com
Cursos Abtua
58
Como a linguagem Java utiliza herana simples, a regra bsica para resolver problemas de ambiguidade ou ocultamento utilizar this para referenciar membros da classe herdeira, e super para referenciar membros da classe parenta.
Sobrescrita
Ao se herdar uma classe no apenas permitido acrescentar campos e mtodos, tambm possvel sobrescrever mtodos da classe pai, alterando o comportamento no filho. Para sobrescrever um mtodo do pai, o filho deve utilizar a mesma declarao, ou seja, mesmo nome, tipo de retorno do mtodo10, alm do mesmo nmero e tipos dos argumentos. Tambm permitido aumentar a visibilidade (por ex.: um mtodo protected no pai pode ser public no filho), mas no o inverso. Nota: A partir da verso 1.5 da linguagem, recomendado o uso da anotao @Override. Essa anotao garante que o compilador far uma checagem extra para ter certeza que a classe filha estar sobrescrevendo um mtodo da classe pai e no sobrecarregando. A sobrescrita permite que as vrias classes que compartilhem um mesmo ancestral possam manter uma interface consistente, mas cada qual com sua implementao particular.
public class Veiculo { public double acelerarZeroCem() { return 25.0;//seg} } public class Fusca extends Veiculo { @Override public double acelerarZeroCem() { return 15.5e3;//seg} } public class EsportivoV8 extends Veiculo { @Override public double acelerarZeroCem() { return 5.0;//seg} } ... Veiculo misterio = new Fusca(); System.out.println(misterio.acelerarZeroCem()); //imprime 15500.0 mistrio = new EsportivoV8(); System.out.println(misterio.acelerarZeroCem()); //imprime 5.0
Invocao Virtual Similar ao processamento dos construtores, ao se invocar um mtodo de um objeto a JVM ir procurar pela implementao do mtodo a partir da classe da referncia atual at chegar a Object (a base de todos os objetos). Ex.:
//GerenteFuncionario Object Gerente g = new Gerente(); g.toString(); //Procura em Gerente, no encontra //Procura em Funcionario, no encontra //Procura em Object, encontra Funcionario f = new Gerente();
10
Uma classe herdeira pode sobrescrever um mtodo do parente se o tipo do retorno for do mesmo subtipo, isso chamado de covarincia.
www.abutua.com
Cursos Abtua
59
f.toString() //Procura em Funcionario, no encontra //Procura em Object, encontra f.observaTrabalho(g); //Procura em Funcionario, no encontra //Procura em Object, no encontra //Erro
Ocultamento de campos e de mtodos de classe Deve-se tomar muito cuidado quando sobrescrita, ela funciona apenas para mtodos do objeto. As classes herdeiras que declaram um campo ou, um mtodo esttico com o mesmo nome declarado no parente, o membro deste ltimo ficar oculto. Acessar o membro de uma instncia do herdeiro atravs de uma varivel da classe parente ir revelar o valor do parente. Ex.:
public classA { public int var = 0; } public classB extends classA { public double var = 5.5; } ... classA a = new classA(); classA b = new classB(); classA x = b; System.out.println(a.var); //imprime: 0 System.out.println(b.var); //imprime: 5.5 System.out.println(x.var); //imprime: 0
www.abutua.com
Cursos Abtua
60
Mdulo 5 Captulo 13
Classe Abstrata, Interface, Composio e Agregao.
Classes Abstratas
Ao se modelar os objetos, seguindo os princpios da engenharia de software para reutilizao de cdigo, podem ocorrer situaes onde um objeto possua estado e comportamentos bsicos que sero compartilhados por todos seus herdeiros. Estes ltimos se utilizaro de sobrescritas e sobrecarga aonde for necessrio. Mas esse objeto por si s no pode ser construdo11, pois ele incompleto. Seus herdeiros iro complet-lo. Esses objetos so chamados de abstratos. Para declarar um tipo de objeto abstrato utiliza-se o modificador abstract antes da palavra chave class. Sintaticamente, a declarao de uma classe abstrata e de uma classe concreta similar. Com duas excees: Uma classe abstrata pode conter mtodos tambm abstratos, mas sem os modificadores private, static ou final. A classe abstrata em si tambm no pode ser final, pois defende o propsito da classe abstrata que o de ser completada pelos herdeiros.
Nota: Mesmo no podendo instanciar diretamente uma classe abstrata possvel declarar variveis das mesmas, tambm podem ser utilizadas como tipo de retorno de mtodos. As classes abstratas podem conter construtores com a finalidade de inicializar campos. A representao de uma classe abstrata em UML a mesma de uma classe, com a adio da palavra/smbolo: abstract junto ao nome da classe.
Mtodos Abstratos
Uma classe abstrata pode conter mtodos abstratos. Eles tm a funo de forar o herdeiro a implementar um contrato, ou um comportamento necessrio em todos os objetos. Os mtodos abstratos so declarados sem implementao, ou seja, terminam em ponto-evrgula. <modificadores> abstract <tipo_retorno> nome(<parmetros>); No so permitidas combinaes de modificares abstratos com: private, static e final. A implementao de um mtodo abstrato pelo herdeiro segue as mesmas regras de sobrescrita abordadas em Herana. Exemplo:
11
Em termos de programao/linguagem, implica que no possvel utilizar new para criar uma instncia de uma classe abstrata.
www.abutua.com
Cursos Abtua
61
Uma aplicao financeira faz tarefas de clculo e converso que, do ponto de vista matemtico, so iguais para todos os herdeiros. Estes devem apenas fornecer parmetros de correo para os clculos. Uma forma de se implementar esse contrato :
public abstract class CaixaFinanceiro { public double doCalculus() { return 4500.00 * getTacha(); } protected abstract double getTacha(); } public class CaixaDoisTresCinco { private final double taxa = 2.35; protected double getTacha(){ return taxa; } } ... CaixaFinanceiro cx = new CaixaDoisTresCinco(); System.out.println(cx. doCalculus());//imprime 10.575,00
A representao de um mtodo abstrato em UML a mesma para os mtodos, com a diferena de estilo itlico.
Interface
Uma classe abstrata pode representar os estados e comportamentos (internos ou externos) que todos os objetos descendentes devem apresentar da mesma forma ou de forma similar. Mas quando se deseja apenas modelar os comportamentos externos, estabelecer um contrato com outros objetos, no importando qual o objeto concreto? Nesses casos deve-se utilizar uma classe especial chamada interface. Uma interface declara em Java como: <modificador>* interface nome <interfaces parentes> { <constantes>* <mtodos>* <tipos>* } Onde: <modificador>: nico permitido public. Caso omitido ser package. <interfaces parentes>: atravs de extends pode-se herdar outras interfaces. <constantes>: todos os campos sero public static final, podendo os modificadores ser omitidos. <mtodos>: todos os mtodos sero public abstract, podendo os modificadores ser omitidos. <tipos>: todas as classes internas sero public static, podendo os modificadores ser omitidos.
www.abutua.com
Cursos Abtua
62
Nota: Assim como para as classes abstratas, possvel declarar variveis com o mesmo tipo da interface, tambm podem utiliz-las como tipo de retorno de mtodos. As regras de chamada de mtodo virtual sero aplicadas na busca pela implementao dos mtodos da interface. A representao de uma interface em UML a mesma de uma classe, com a adio da palavra/smbolo: interface junto ao nome da classe e todos os membros com estilo itlico.
Implement
A forma como um objeto declara sua aderncia a um contrato (interface) utilizando a palavra chave implements. Ele deve ser escrito aps o nome da classe e antes do incio do bloco dos membros. Por conveno, caso a classe esteja herdando de outra, a declarao de implements deve vir aps o nome da classe parente. Como as interfaces representam o contrato entre objetos, nada impede que a declarao de um objeto implemente mais do que um contrato. Para tanto basta declarar o nome de cada interface separa por vrgula. <modificador> [abstract] class <nome> [extends <nome>] [implements <nomes>+] { <...> } A classe que declara implementar uma interface deve fornecer a programao de todos os mtodos de todas as interfaces que implementa. Apenas as classes abstratas podem programar parcialmente uma interface (delegando para os herdeiros a tarefa de completar a classe mais a interface).
public interface Mensuravel { double getArea(); double getAlturaTotal(); double getLarguraTotal(); } public abstract ObjGeometrico implements Mensuravel{ protected Object referencia; public double getArea() { return 0.0; } } public class Circulo extends ObjGeometrico{ double getAlturaTotal() { ... } double getLarguraTotal() { ... } }
Uma classe concreta que herde de um parente que implementa uma interface tambm herdar indiretamente a interface. Caso a classe parente no deseje que os mtodos da interface sejam sobrescritos pelos herdeiros (total ou parcialmente) ela deve implement-los como final.
public class Gerente extend Funcionario implements Subordinado { ... } public class Circulo implements Mensuravel, Comparavel { ... }
Uma das representaes UML da implementao de uma interface por um objeto um pequeno crculo ligado classe que implementa a interface:
www.abutua.com
Cursos Abtua
63
Interface Classe
Extend
Como todo contrato, as interfaces devem ser muito bem elaboradas para o correto interrelacionamento entre os objetos que as utilizam. Entretanto isso nem sempre possvel. Dado o exemplo: Uma interface NavegaLista faz parte de uma biblioteca que utilizada por centenas de outros objetos de uma framework. Mais tarde decidiu-se sobrecarregar um mtodo interface. Nesse momento todas os objetos que implementam essa interface iro emitir erros de compilao! Para casos como esse, ou quando se deseja mesclar duas ou mais interfaces em uma s, a declarao da interface aceita a palavra reservada extends. Como em herana de classe, a declarao da nova interface herdar todos os mtodos das outras interfaces que ela estende.
public interface Mensuravel { public double getArea(); } public interface Mensuravel_v2 extends Mensuravel { public float getArea(); } public interface Mensuravel_integer extends Mensuravel_v2 { public byte getArea(); public short getArea(); public int getArea(); }
Nota: Uma interface um tipo especial de classe, portanto operadores como instanceof funcionam para interfaces tambm.
Exemplo composto
Avies e Pssaros. Todos os Avies voam, nem todos os pssaros voam. Jato um tipo de avio e, portanto, voa. Pinguim tipo de um pssaro, mas no voa. Papagaio tipo um pssaro que voa.
www.abutua.com
Cursos Abtua
64
Voar <<interface>>
Passaro <<abstract>> #field_1:String #field_2:int #method_A():void
+levantarVoo():void
Aviao <<abstract>> #field_1:String #field_2:int #method_B():void #method_C(p1:int):voi d
Pinguim
Papagaio Jato -frase:String
+method_C(p1:int):void +method_D():float
+method_F():String
-turbinas:Array +method_C(p1:int):void +method_E():float
Associaes
Existem outras formas de se produzir novos objetos, seguindo os preceitos de reutilizao de cdigo da engenharia de software, que pela associao de objetos. A associao de objetos pode ser: Normal: um objeto possui referncias para outros objetos, mas ele no depende ou controla esses outros objetos. Composio: um objeto possui referncias para outros objetos, ele necessita desses outros objetos e responsvel pelo seu tempo de vida. Agregao: um objeto possui referncias para outros objetos, ele necessita desses outros objetos, mas no controla seu tempo de vida.
Todos so estilos e tcnicas de programao que podem representar uma relao entre objetos que no seja necessariamente do tipo um.
Composio
A composio tambm chamada de associao forte. Ela representa uma relao composto/componente de. Ela simboliza uma relao onde o todo precisa das partes para existir e as partes no podem existir sem o todo. A relao de composio indica que o objeto continer (container) responsvel pelo tempo de vida de seu contedo, ou seja, o objeto componente deveria ser destrudo (ou torna-se invlido) quando o continer for coletado. Como na linguagem Java, aonde todos os objetos so referncias, e um objeto no pode ser coletado enquanto houver referncias para ele, a aplicao do conceito de composio deve ser enforcado por conveno pelo programador. Exemplo: uma forma de alcanar a
www.abutua.com
Cursos Abtua
65
composio com o uso de variveis privadas instanciadas no construtor e no exp-las diretamente atravs de mtodos get. Tpico avanado: Os mtodos do continer que necessitem expor um componente podem faz-lo atravs de cpias, serializao, proxies, ou ainda por referncias fracas. Caso receba o componente como um parmetro do construtor ou mtodo, este deve ser fornecido atravs de uma fbrica, instanciado diretamente no parmetro ou ser clonvel [tpico avanado] Um exemplo geral o ClassLoader inicial. Ele um continer de todos os objetos carregados na execuo da JVM. Ao finaliz-lo, termina a execuo da JVM.
public class Carro { private Motor motor; public Carro() { motor = new Motor(2.0); } } ... { //c1.motor construdo junto com o carro Carro c = new Carro(); } //Neste ponto c1 no existe mais, e nem c1.motor
A representao UML de uma agregao dada por um losango preenchido: Continer Componente
Agregao
A agregao tambm chamada de associao fraca. Ela representa uma relao tem um. Ela simboliza uma relao onde o todo precisa das partes, e estas so independentes do todo. A relao de agregao indica que o objeto continer no necessariamente responsvel pela criao e nem pelo tempo de vida de seus componentes, ou seja, o objeto componente poderia at tornar-se invlido antes que o continer possa utiliz-lo (tornando importante verificar se o objeto no nulo caso haja esse risco). Basicamente qualquer campo pblico ou protegido/privado com get/set, pode ser um objeto agregado. Nota: Como na linguagem Java, aonde todos os objetos so referncias, e um objeto no pode ser coletado enquanto houver referncias para ele, o programador deve ter ateno para no reter referncias a objetos que no deveria.
www.abutua.com
Cursos Abtua
66
public Curso { private Aluno[] inscritos = new Aluno[35]; private vagas = 35; public addMatricula(Aluno a) { if(vagas >= 0) { inscritos[vagas-1] = a; vagas--; } } }
A representao UML de uma agregao dada por um losango: Continer Agregado
www.abutua.com
Cursos Abtua
67
Mdulo 6 Captulo 14
Excees, try-catch e assero
Excees
Excees so eventos que podem ocorrer durante a execuo da aplicao. Esses eventos ocorrem por desvios ou situaes fora da lgica programada. Existem duas categorias de excees, as que podem ser esperadas (checked) e as que no podem (unchecked).
Exception
As excees esperadas so situaes aonde possvel tentar contornar o problema, podendo ou no ocasionar a interrupo da aplicao. So casos previstos: tentar converter um caractere que represente um nmero em um nmero (ex.: 2 2), tentar abrir um arquivo que no existe, um servidor que demora a retornar uma resposta etc. Esses casos so representados na linguagem Java como descendentes da classe Exception.
RuntimeException e Error
As excees no esperadas so situaes aonde no possvel contornar o problema, podendo, nos piores casos, interromper a aplicao de forma anormal. So exemplos: erros de lgica em outros objetos que interferem na lgica do algoritmo local, o uso indevido de outros objetos pelo algoritmo local, ou ainda erros fora do controle da aplicao como falta de memria do sistema. Quando um erro interno aplicao, por exemplo, invocar um mtodo com argumentos invlidos ou nulo, so emitidos objetos descendentes de RuntimeException. Quando um erro externo aplicao, por exemplo, entre a JVM e o sistema operacional, so emitidos objetos descendentes de Error. Nesses casos a interrupo abrupta da aplicao inevitvel.
Declarando Excees
A linguagem Java possui a regra Catch or Specify Requirement (Capture ou Especifique Requerimento). Essa regra diz que uma exceo deve ser capturada (catch) ou declarada no mtodo (throws). Ela se aplica a todas as excees esperadas (Exception) e opcionalmente as no esperadas por erros de lgica (RuntimeException).
Try-Catch
A linguagem Java aborda as excees como objetos. Todas as excees tm como ancestral comum a classe Throwable, como pode ser visto abaixo:
www.abutua.com
Cursos Abtua
68
RuntimeExcep Exception Throwable Error ...
...
...
Quando ocorre uma exceo dito que o sistema est jogando/arremessando (throwing) um objeto que contm as informaes do erro. O objeto da exceo percorrer todos os mtodos desde onde foi arremessado at que seja capturado por um dos mtodos chamadores ou at alcanar o mtodo principal da aplicao, main. Mtodo C: no captura
Uma declarao joga exceo
Exception Mtodo B: no captura Exception Mtodo A: captura Mtodo Main Nota: se uma exceo no for tratada at o mtodo principal, a resoluo padro terminar a aplicao de forma anormal e imprimir todo o caminho da exceo (stacktrace). A forma como se captura uma exceo na linguagem Java com o bloco try-catch, com a seguinte sintaxe: <declaraes> try { <declaraes> } catch(<descendente de Exception>) { <declaraes> } <catches>
Dentro do bloco try so colocadas as declaraes da lgica que precisa ser monitorada. Aps o bloco try so declarados um ou mais blocos catch. Cada bloco catch captura e permite fazer o tratamento de uma classe de exceo. Nota: Apenas um bloco catch executado para o tratamento da exceo. O bloco escolhido o bloco que contenha a mesma classe da exceo, ou que seja uma superclasse da mesma. Portanto a ordem de captura deve ser observada. Ex.:
www.abutua.com
Cursos Abtua
69
try { ... } catch(FileNotFoundException fnf) { ... //ok captura se arquivo no existir } catch(Exception e) { ... //essa exceo abrange todas as excees } catch(EOFException eof) { ... //erro, essa exceo nunca ser alcanada }
Finally
Caso seja necessrio completar alguma lgica aps ter ocorrido uma exceo, a nica forma de garantir que um cdigo seja executado aps o ltimo bloco catch com o uso do bloco finally. Exemplo: Um objeto que representa um soquete de comunicao (socket) pode estar aberto, mas ainda no estar preparado para ser escrito (enviar dados).
... Socket s = null; try{ s = Socket.open(...);//pode emitir exceo de abertura s.send(...);//pode emitir exceo de escrita } catch(Exception e) { ...//no importa qual o erro } finally { if(s != null) s.close(); //se o objeto existir, feche } ... //as declaraes aqui podem no ser executadas
Throws
Seguindo a regra Catch or Specify Requirement, se um mtodo no ir tratar uma possvel exceo esperada, ou caso o programador crie novas excees que devam ser tratadas por quem utilizar o novo objeto, necessrio que ele declare o requerimento dessas excees. A sintaxe acrescenta a palavra chave throws seguida das classes de excees separadas por vrgula: <modificadores> <tipo de retorno> mtodo(<argumentos>) throws <excees> { <declaraes> } Nota: A declarao de requerimento de exceo faz parte da assinatura do mtodo e segue as regras de sobrescrita para herana: Um mtodo sobrescrito num herdeiro deve declarar as mesmas classes, ou superclasses, das excees requeridas no mtodo parente.
public class Parente { ... public void metodoParente() throws FiloNotFoundException { ... } } //OK, Exception a superclasse de FiloNotFoundException public class Herdeiro { ...
www.abutua.com
Cursos Abtua
70
@Override public void metodoParente() throws Exception { ... } }
Throw
Tanto para as classes de excees j existentes quando para as excees criadas pelo programador, a forma pela qual uma exceo pode ser lanada, ou relanada de dentro de um bloco catch, atravs do operador throw. Ex.:
public class MyException extends Exception { ... } public void metodoF() throws MyException { throw new MyException(Mensagem de Erro); } public void metodoA() throws MyException { try { metodoF(); } catch(MyException ex) { throw ex; //relana a exceo } }
Assero (assert)
Durante o desenvolvimento torna-se interessante fazer verificaes extras quanto ao estado de objetos ou a valores em fluxos de controle. A linguagem Java oferece o operador assert: assert <expresso> [: <texto complementar>]; Onde: <expresso> uma expresso booleana que, caso resulte em falso, ir emitir a exceo AssertionError. <texto complementar> um objeto complementar que ser convertido para String (se j no o for) e entrar como a mensagem no argumento na criao de AssertionError.
Nota: As asseres partem do princpio que uma aplicao deve funcionar da mesma maneira com ou sem as asseres ativadas. Elas devem ser utilizadas apenas para verificao e/ou confirmao da lgica de operao de um algoritmo, nunca como parte integrante de condies. Por padro as asseres no so ativadas durante a execuo12, mas apenas em ambiente de depurao (debug). Exemplo de bom uso de asseres: Confirmar que um contador est sendo incrementado ou decrementado.
12
Apesar de ser possvel ativar as asseres durante a execuo atravs o parmetro ae do executor da JVM.
www.abutua.com
Cursos Abtua
71
public class Turma extend Sala { public addAluno(Aluno a) throws VagasEsgotadasException { int vagas = getVagas(); if(vagas > 0) { ...//adiciona aluno assert (getVagas() == vagas 1); } else { assert vagas < 0: no deveria ser negativo; throw new VagasEsgotadasException(); } } }
Exemplo de mal uso de assero: Verificar dentro do assert se uma expresso retornou true.
...class Session ... public boolean removeAttribute(String attributre); ... ... meu mtodo ... Session s = getSession(); assert(s.removeAttribute(compras)); //neste caso quando a lgica do mtodo falha aplicao rodar sem assertion (-ae) a
Complemento
Algumas excees e erros de Java: Exception RuntimeException IndexOutOfBoundsException ArrayIndexOutOfBoundsException: quando se tenta utilizar um ndice mais alto que maior ndice de uma array. Exemplo int[] x = new int[5]; x[7] = 2; ClassCastException: em herana, quando tenta-se converter um objeto de uma classe parente para uma classe filha mas o objeto no dessa classe filha. IllegalArgumentException: quando uma funo foi chamada com um argumento inapropriado. Exemplo: um mtodo s aceita valores de 0 a 10 e foi passado 11. NumberFormatException: quando se tenta converter uma String em um nmero mas a String no contm uma representao de um nmero IllegalStateException: quando se tentar executar uma tarefa quando o objeto ainda no esta pronto. Ex.: executar write antes de um arquivo estar aberto. NullPointerException: sempre que se tentar executar uma tarefa sobre um objeto nulo Error AssertionError: Quando uma expresso assert resulta em false LinkageError ExceptionInInitializerError: quando ocorre um erro dentro de um inicializador esttico NoClassDefFoundError: Quando a JVM, o classloader ou o operador new tenta chamar uma classe no definida VirtualMachineError
www.abutua.com
Cursos Abtua
72
StackOverflowError: Quando estoura a capacidade da pilha de chamada de mtodos (mtodos chamando mtodos recursivamente)
www.abutua.com
Cursos Abtua
73
Mdulo 6 Captulo 15
Colees, Genricos, Comparao e Ordenao
O Framework de Colees
O Java Collection Framework uma arquitetura para representar e manipular colees de dados. Ela composta de interfaces, implementaes e algoritmos. De forma abstrata, uma coleo um objeto container que agrupa um conjunto de objetos elementos. Atravs da coleo definida uma forma para armazenar, buscar, ordenar, recuperar e apagar elementos. O framework oferece diversas implementaes dos containers e algoritmos de ordenao e busca, possibilitando ao programador concentrar-se na lgica de sua aplicao, no necessitando escrever cdigos para movimentao de dados, sincronia etc. As interfaces ajudam a produzir cdigo reutilizvel e consistente, permitindo inclusive a portabilidade da aplicao para diferentes implementaes. Os algoritmos so polimrficos, possibilitando que tanto colees de objetos do usurio quanto para objetos do sistema e de interface grfica possam se beneficiar do framework. Nota: Todos objetos e interfaces tratados nesse captulo fazem parte do pacote java.util.* Obs. Geral: O programador deve sempre ter cuidado ao lidar com colees de objetos. Os algoritmos que mantm a ordem dos elementos (como algoritmos de rvore balanceada) partem do princpio da imutabilidade dos objetos. Procurar sempre retornar a interface mais especfica e receber como argumentos as mais genricas.
Interfaces
As interfaces de colees definem a forma de como interagir com a coleo para insero, remoo, recuperao, busca e ordenao. Cada interface reflete uma viso de coleo, sendo mais genricas as interfaces de coleo (Collection) e mapa (Map). Derivadas de Collection existem as interfaces para lista (List), conjunto (Set) e fila (Queue). Finalmente existem as interfaces ordenadas para conjunto (SortedSet) e mapa (SortedMap).
Collection
Map
List
Set
Queue
SortedMap
SortedSet
www.abutua.com
Cursos Abtua
74
Nota: Para manter o nmero de interfaces pequeno o framework de colees no oferece mtodos para todos os tipos de variantes de interfaces (por ex.: imutvel, somente leitura, sincronizado etc). As interfaces oferecem um conjunto de mtodos que so marcados como opcional. necessrio ler a documentao para saber seu comportamento. Caso seja invocado um mtodo no suportado ser lanada a exceo UnsupportedOperationException.
Collection
A interface mais bsica da API de colees a Collection. Ela oferece o contrato bsico de manipulao dos itens da coleo. tambm utilizada nos construtores das outras subinterfaces possibilitando converter uma subcoleo em outra. Uma coleo representa um agrupamento de elementos, sem nenhuma implicao de ordem, repetio ou regras para insero ou remoo. Uma Collection<E> oferece os mtodos para: Conferir o tamanho da coleo o size():int retorna a quantidade de elementos o isEmpty():boolean retorna verdadeiro se a coleo estiver vazia Verificar a existncia de um elemento o contains(o:Object):boolean Manipular a coleo (opcionais) o add(e:E) :boolean para adicionar um elemento o remove(o:Object):boolean para remover um elemento Navegar pelos elementos da coleo o iterator():Iterator<E> retorna uma interface Iterator para o tipo dos elementos
Tambm so oferecidas operaes em volume (containsAll e opcionais addAll, removeAll, retainAll, clear). Todos esses mtodos recebem como parmetro objetos de Collection<E> e retornam um booleano, exceto clear que remove todos os elementos da coleo. Por fim existem dois mtodos toArray que retornam os elementos da coleo como um array para compatibilidade com mtodos legados. Nota: todas as operaes que alteram os elementos da coleo so marcadas opcionais e esto sujeitas a emitir a exceo UnsupportedOperationException.
List
A interface List<E> representa uma lista de elementos. Uma lista uma coleo ordenada de elementos, podendo conter elementos duplicados. Alm dos mtodos de Collection<E> so oferecidos mtodos relativos posio do elemento na coleo: Posicional (positional): o get(idx:int):E retorna o elemento na posio dada o set(idx:int, e:E):E altera o elemento na posio dada o add(idx:int, e:E) altera a coleo adicionando o elemento da posio dada www.abutua.com
Cursos Abtua o o
75
remove(idx:int):E altera a coleo removendo o elemento da posio dada addAll(idx:int, c:Collection<? extends E>):boolean adiciona todos os elementos da coleo dada a partir da posio dada Procura (search): o indexOf(o:Object):int devolve o ndice da primeira ocorrncia do elemento o lastIndexOf(o:Object):int devolve p ltimo ndice do elemento Faixa (range): o subList(a:int, b:int):List<E> retorna uma sublista Interadores:
Devido a natureza das listas oferecido um subtipo de Iterator chamado ListIterator. Essa nova interface possibilita a navegao bidirecional dos elementos da lista e a possibilidade de alterar um elemento. Nota: A alterao de um elemento pode levar a implementao da interface a reorganizar toda a lista, com o ListIterator a reorganizao dos elementos no invalida o ponteiro. ListIterators so obtidos atravs dos mtodos: o o listIterator():ListIterator<E> retorna a interface especializada listIterator(int index):ListIterator<E> retorna a interface especializada a partir da posio dada
A interface especializada ListIterator<E> oferece os mtodos adicionais: hasPrevious():boolean indica se existe um elemento anterior a posio atual previous():E retorna o elemento da posio atual e retrossede o cursor nextIndex():int retora o ndice do elemento posterior ao atual previousIndex():int retora o ndice do elemento atual set(e:E) altera o elemento atual add(e:E) adiciona o elemento na posio atual
Exemplo de um objeto ListIterator para uma lista de N elementos: Elemento [erro] ndice -1 0 Cursor Posio Inicial .hasNext:true .nextIndex:0 .hasBefore:false .previousIndex:-1 .next:E(0) .previous:[erro] E(0) ... ... N-1 E(n-1) N [erro]
.hasNext:true .nextIndex:1 .hasBefore:true .previousIndex:0 .next:E(1) .previous:E(0)
.hasNext:false .nextIndex:N .hasBefore:true .previousIndex:N-1 .next:[erro] .previous:E(n-1)
Nota: Assim como para as colees, set e add em ListIterator so opcionais.
www.abutua.com
Cursos Abtua
76
Set
A interface Set<E> representa um conjunto (no sentido matemtico) de elementos. Um conjunto no contm elementos duplicados. A ordem em que os elementos se encontram depende da implementao utilizada. A interface de Set oferece os mesmos mtodos de Collection<E>, apenas reforando a regra para elementos nicos. Para isso os mtodos equals e hashCode da calsse Object, e compareTo da interface Comparable, so muito importantes para garantir a unicidade dos elementos. Uma das melhores caractersticas de Set sua utilizao em lgebra de conjuntos onde: Unio representada pelo mtodo addAll Interseco representada pelo mtodo retainAll Diferena representada pelo mtodo removeAll Subconjunto representado pelo mtodo containsAll
Set<Integer> a, b, aUb, aIb, aMb; a = new HashSet<Integer>(); b = new HashSet<Integer>(); Collections.addAll(a, 1, 2, 3); Collections.addAll(b, 2, 3, 4); aUb = new HashSet(a); aIb = new HashSet(a); aMb = new HashSet(a); aUb.addAll(b); aIb.retainAll(b); aMb.removeAll(b); System.out.println(a); System.out.println(b); System.out.println(aUb); System.out.println(aIb); System.out.println(aMb); //cria obj. a //cria obj. b //coloca elem. em a //coloca elem. em b //clona a //clona a //clona a //A unio B //A inter B //A menos B //[1, //[2, //[1, //[2, //[1] 2, 3] 3, 4] 2, 3, 4] 3]
Queue
A interface Queue<E> representa uma fila de elementos. A principal restrio de uma fila a retirada dos elementos apenas pelo comeo ou cabea (head). O que difere no uso de filas so a forma de insero de novos elementos e opcionalmente uma limitao de quantidade mxima de elementos, por exemplo: FIFO (First-in-First-out: primeiro a chegar primeiro a sair) aonde os novos elementos so inseridos ao fim da fila (tail) e Fila de Prioridade (PriorityQueue) aonde os novo elementos causam a reordenao da fila dependendo da prioridade do elemento. A interface de Queue oferece alm dos mtodos de Collection<E>, um conjunto de operaes para as situaes onde a quantidade de elementos limitada e para a consulta do elemento head. Os mtodos possuem uma verso com e sem exceo: Com Exceo
www.abutua.com
Cursos Abtua o
77
add(e:E):boolean [Collection] Tenta adicionar elemento. Emite IllegalStateException se a fila estiver cheia o element():E Consulta head e emite NoSuchElementException se a fila estiver vazia o remove():E Remove head e emite NoSuchElementException se a fila estiver vazia Sem Exceo o offer(e:E):boolean Tenta adicionar elemento. Retorna false se a fila estiver cheia o peek():E Consulta head e retorna null se a fila estiver vazia o poll():E Remove head e retorna null se a fila estiver vazia
Nota: As implementaes de fila no aceitam a insero de objetos nulos (null), com exceo de LinkedList por motivos de compatibilidade com cdigo legado.
Map
A interface Map, tambm conhecida como dicionrio, uma coleo de pares de elementos. Cada par de elementos formado por uma chave e um valor. O conjunto de chaves em um mapa nico, ou seja, no h chaves duplicadas. Cada chave aponta para no mximo um valor. Uma Map<K,V> oferece os mtodos: put(key:K, value:V):V Adiciona um elemento com valor V na chave K get(key:Object):V Retorna o valor da chave K remove(key:Object):V Remove o elemento (dupla chave-valor) dada a chave containsKey(key:Object):boolean Verifica se exista a chave na coleo containsValue(value:Object):boolean Verifica se existe o valor na coleo size():int retorna a quantidade de pares chave-valor isEmpty():boolean retorna verdadeiro se a coleo estiver vazia putAll(m:Map<? extends K, ? extends V>) similar a unio em Set. Valores so atualizados se as chaves do destino forem iguais as chaves correntes e novas duplas so adicionadas caso a chave no exista clear() remove todos as duplas da coleo keySet():Set<K> retorna um conjunto (Set) com apenas as chaves values():Collection<V> retorna uma coleo com apenas os valores entrySet():Set<Map.Entry<K,V>> retorna um conjunto dos pares chave-valor
Map.Entry uma interface aninhada em Map que permite visualizar os pares de elementos do dicionrio como um nico objeto com dois campos: Chave (somente leitura) o getKey():K retorna a chave Valor o getValue():V retorna o valor o setValue(value:V):V altera o valor
www.abutua.com
Cursos Abtua
78
Nota: Os tipos parametrizados para chave e valor (K, V) no precisam ser necessariamente diferentes. Eles podem ser o mesmo tipo, por exemplo: <Integer, Integer>. Podendo at mesmo ser uma relao de herana (extends). Multimapa O Framework de colees no oferece especificamente nenhuma interface para multimapas, mas o programador pode utilizar qualquer uma das interfaces de colees como o tipo parametrizado de valor. Exemplo: Map<String, Set<String>> poderia ser um dicionrio de sinnimos, onde cada palavra chave leva a uma lista de palavras de mesmo significado.
Implementaes e Wrappers
At o momento foram vistas as interfaces de coleo, elas expe a forma concisa de se lidar com agrupamentos de elementos. No entanto, cada situao pode necessitar de uma forma diferente de implementao da interface. O Framework de Colees de Java oferece um conjunto varivel de implementaes para as interfaces. Essas implementaes podem ser: De uso geral (general-purpose): So implementaes para uso padro. De uso especfico (special-purpose): So implementaes para comportamentos especficos ou restries de alguma forma Para uso em multilinhas (concurrent): So implementaes que garantem acesso aos dados para uma linha de execuo (thread) por vez. Invlucros (wrappers): So implementaes que combinam (ou embrulham) outras implementaes como, por exemplo, as implementaes gerais, aplicando restries ou novos comportamentos. De convenincia (convenience): Normalmente so mtodos fbrica para implementaes como conjuntos de um nico elemento, ou listas com N elementos de mesmo valor X. Abstratas (abstract): So objetos parciais com as tarefas e estados mais comuns do controle de colees para serem completadas pelo programador
Implementaes de uso geral List: ArrayList: Baseada em array, possui tempo de acesso constante e tempo de leituraescrita linear LinkedList: Baseado em uma lista ligada, possui tempo de acesso linear e tempo de leitura-escrita constante
Set: Hashset: Baseado em uma tabela de hash, no garante a ordem dos elementos, tempo de acesso constante.
www.abutua.com
Cursos Abtua
79
TreeSet: Baseado em uma rvore red-black, garante a ordem dos elementos, tempo de acesso funo de logaritmo. Para ter acesso aos critrios de ordenao e outros mtodos convenientes pasta utilizar a interface SortedSet. LinkedHashSet: Baseado em uma tabela de hash mais a ligao entre os valores, oferece tempo de acesso similar a HashSet e permite navegar pelos elementos por ordem de insero
Queue: LinkedList: mesma implementao de List, oferece a doutrina FIFO PriorityQueue: ordena os elementos que forem inseridos segundo a ordem natural ou uma implementao de Comparator que for passada no construtor.
Map: HashMap: baseado em uma tabela de hash, mesmas caractersticas de HashSet TreeMap: mesmas caractersticas de TreeSet. Para ser ter acesso aos mtodos especficos de ordenao basta utilizar a interface SortedMap. LinkedHashMap: funcionamento similar a LinkedHashSet, acrescenta a opo de ordenar as chaves por acesso em vez de ordem de insero.
Nota: A ordenao dos elementos por acesso s est disponvel pelo construtor completo de LinkedHashMap. O mtodo removeEldestEntry(entry:Map.Entry):boolean chamando por put e putAll e indicaro o elemento a ser removido (entry), caso o retorno seja true o elemento em questo removido. A implementao padro retorna false. Implementaes Wrapper A maioria dos wrappers esto disponveis como mtodos fbrica da classe Collections. Existem wrappers para sincronizao (synchronize) para controle de mltiplas linhas de execuo (multithread), somente leitura (unmodifiable) e validao (checked). Os mtodos fbrica possuem a assinatura: public static <retorno> <wrapper><nome>(<interface>); onde: <retorno> a interface desejada <wrapper> o nome em ingls de um dos wrappers desejados (synchronize, unmodifiable, checked etc) <nome> o nome da interface desejada <interface> o argumento com a assinatura da interface desejada com os parmetros de tipo ajustados caso necessrio
Exemplo:
//Uma lista sincronizada public static <T> List<T> synchronizedList(List<T> list); ... List<Integer> f = Collections.synchronizedList(new ArrayList());
www.abutua.com
Cursos Abtua
80
//Thread A f.add(resultadoEquacao()); //Thread B f.add(outraEquacao()); Thread A no terminar //-------------------//Um conjunto imutvel public static <T> Set<T> unmodifiableSet(Set<? extends T> s); ... public class Ilha { public Set<Integer> getEscotilha() { Set<Integer> sequencia = new HashSet<Integer>(); Collections.addAll(sequencia, 4, 8, 15, 16, 23, 42); return Collections.unmodifiableSet(sequencia); } } //Thread B vai ficar travada enquanto
Algoritmos: Comparao e Ordenao

Alm dos mtodos fbrica de wrappers, a classe Collections oferece vrios mtodos que implementam algoritmos como ordenar (sorting), embaralhar (shuffling), inverter ordem (reverse), preencher (fill), copiar (copy), trocar (swap), adicionar (addAll), procura (binarySearch), mximo (maximum) e mnimo (minimum), dentre outros. Nota: A classe Java.util.Arrays tambm oferece diversos algoritmos similares mas para arrays, como binarySearch, deepCopy e fill. Obs.: Arrays.asList permite visualizar um array como uma lista mas, nesse caso, no possvel adicionar ou remover elementos! A maioria dos mtodos baseia-se na comparao entre os elementos da mesma ou de outra coleo. Essa comparao pode ser natural, que para tipos primitivos utiliza o seu valor ou utilizando os mtodos equals e Comparable<T>.compareTo(t:T):int para os tipos de referncias (objetos). Para comparar objetos por outros critrios que no sejam os da ordem natural do objeto, utiliza-se o mtodo compare(t1:T, t2:T):int da interface Comparator<T>. Nota: Para todos os tipos primitivos, Java oferece um objeto wrapper, por exemplo: int Integer, double Double. Todos os wrappers de tipos primitivos sobrecarregam corretamente equals e compareTo para manter o mesmo comportamento da ordem natural das contrapartes primitivas. Assim como outros tipos como Date para data.
Sobrecarregando equals e hashCode

Por padro todos os objetos herdam de Object os mtodos equals e hashCode padro. A implementao padro de equals comprar as duas referncias atravs do operador de igualdade (==) o que resulta na comparao dos endereos de memria dos objetos. A sobrescrita de equals deve ser feita caso se deseje outro tipo de comparao de igualdade. Nota: caso o argumento passado para equals seja nulo (null) o retorno ser falso (false). Uma regra da linguagem Java diz que quando dois objetos so iguais ento o valor de verificao (hashCode) de ambos os objetos tambm deve ser o mesmo: www.abutua.com
Cursos Abtua
81
//Para Objeto obj1 = new Objeto(); Objeto obj2 = new Objeto(); ... if(obj1.equals(obj2)) { System.out.println(obj1.hashCode() == obj2.hashCode());//true }
Isso implica que ao se sobrecarregar o mtodo equals, o mtodo hashCode tambm deve ser atualizado e garantir a consistncia. Nota: Hash um valor gerado atravs de um algoritmo de disperso, esse algoritmo deve sempre gerar o mesmo resultado para as mesmas entradas. Por exemplo: CRC32, MD5, SHA1 so equaes de hash muito comuns. Importante: Os objetos que forem elementos em Set ou chaves em Map devem tambm ser imutveis ou no mnimo somente leitura, pois se o hash mudar (e por consequncia equals) quebrar a consistncia da coleo, que depende de hash para os algoritmos como balanceamento de rvore.
Comparable
Para inseres e remoes o mtodo equals cumpre o papel de comparao. Mas para os mtodos de ordenao necessrio saber se um elemento maior, igual ou menor que outro elemento. A comparao para ordenao completa natural deve ser feita implementando-se a interface Comparable. A interface Comparable<T> define apenas um mtodo compareTo(other:T):int. A implementao desse mtodo deve seguir a lgica e valores de retorno: Se este objeto (this) for menor que o objeto comparado (other), retorna -1 (um negativo) Se este objeto (this) for igual ao objeto comparado (other), retorna 0 Se este objeto (this) for maior que o objeto comparado (other), retorna 1 (um positivo)
Algumas regras para a implementao de compareTo: Dados X, Y e Z o Se a comparao entre X e Y for positiva a comparao entre Y e X deve ser negativa (anticomutativa) o Se a comparao entre X e Y for positiva e a comparao entre Y e Z tambm for positiva, ento a comparao entre X e Z deve ser positiva (transitiva) o Se a comparao entre X e Y resultar que so iguais, ento a comparao entre X e Z deve ter o mesmo resultado da comparao Y e Z (igualitria) o Se a comparao entre X e Y resultar em exceo a comparao entre Y e X tambm deve (simetria de exceo) Se o objeto comparado for nulo o mtodo deve jogar a exceo NullPointerException Se o objeto comparado no for da mesma classe, o mtodo deve jogar a exceo ClassCastException.
www.abutua.com
Cursos Abtua
82
Opcionalmente, quando x.compareTo(y) for zero ento x.equals(y) deve ser verdadeiro. Caso contrrio deve ser informado claramente na documentao do objeto: Nota: esta classe possui uma ordenao natural inconsistente com equals
Nota: Como j mencionado, diversas classes em Java implementam equals e compareTo para poderem ser utilizadas em colees. Os objetos Date so ordenados quando a seu valor cronolgido (ex.: 2012-06-01 < 2012-06-12, 14:00>8:00) e as Strings quanto a seu valor lexicogrfico (ex.: [A-Z][a-z]).
Comparator
Quando se deseja outras opes de ordenao alm da natural, ou para possibilitar o uso de objetos que no possuem ordenao natural (no implementam Comparable) em colees, necessrio criar objetos externos que implementam a interface Comparator<T>. A interface de Comparator define dois mtodos: compare(obj1:T, obj2:T): int Compara dois objetos da mesma classe (obj1 e obj2), segue as mesmas regras de Comparable.compareTo, s que agora com o primeiro objeto explcito. equals(o:Object):boolean Este mtodo, quando implementado manualmente, deve retornar verdadeiro se o outro objeto tambm for um Comparator e se ambos possuem as mesmas regras de ordenao.
Uma forma de implementar Comparator em linha (in-line), tambm chamado de implementao annima (anonymous). Ex.:
//inverte a ordenao natural dos nmeros inteiros Set<Integer> s = new TreeSet<Integer>(new Comparator<Integer>() { @Override public int compare(Integer t, Integer t1) { return (t1 > t)? 1 : (t1 < t)? -1 : 0; } }); Collections.addAll(s, 8, 4, 9, 2, 0); System.out.println(s);//[9, 8, 4, 2, 0]
Genricos
Desde o lanamento da verso Java 5, a linguagem Java adicionou o conceito de genricos. possvel observar o uso dos genricos nas assinaturas de mtodos e classes/interfaces em todo o tpico anterior sobre colees. As classes e mtodos genricos possuem um ou mais parmetro de tipo entre os smbolos de maior-que e menor-que (Map<K, V>). Os genricos so uma facilidade, um recurso da linguagem, que auxilia na converso e imposio de regras para tipos de objetos durante o processo de compilao. Observe as situaes no trecho de cdigo abaixo:
//Interface de Lista antes da verso Java 5 List contagem = new LinkedList();
www.abutua.com
Cursos Abtua
83
contagem.add(new Integer(1)); contagem.add(new Integer(2)); contagem.add(new Integer(3)); contagem.add(new Double(3.2)); //(1) for(Iterator i = contagem.iterator(); i.hasNext()) { Integer valor = (Integer) i.next(); //(2 e 3) }
(1)As colees antes da verso Java 5 eram colees de objetos (Object), mesmo querendo-se fazer uma lista de inteiros, como no exemplo dado, no era possvel prevenir que uma adio de um objeto Double ocorresse em uma coleo de Integer (ambos descendem de Object, indiretamente). (2)Todos os outros objetos de colees tambm s recebiam Object e retornavam Object, desta forma, mesmo sabendo que a coleo era de objetos de Integer, torna-se necessrio a converso (cast) do tipo antes da atribuio. (3) Como o tipo dos dados da lista no mais uniforme (agora possui um Double em meio aos Integer) o cdigo causar uma exceo. Os genricos trazem a soluo para esses problemas (em tempo de compilao) introduzindo na linguagem as classes e mtodos com tipos parametrizveis, ou tipos incompletos. Os tipos parametrizveis so como variveis, mas que so consumidas pelo compilador. Elas devem ser completadas pelo programador para que o compilador possa aplicar as converses (cast) automaticamente assim como emitir erros de compilao para situaes como as (1, 2 e 3) do exemplo dado. Classes parametrizadas As classes parametrizadas possuem a sintaxe: <modificador> nome<<parmetros>> <heranas e excees> { <membros> } Onde: <parmetros> so argumentos de tipo que sero informados pelo programador consumidor da classe
Voltando ao exemplo anterior, agora parametrizado:

//Interface com tipo parametrizado Lista<E> List<Integer> contagem = new LinkedList<Integer>(); contagem.add(new Integer(1)); contagem.add(new Integer(2)); contagem.add(new Integer(3)); contagem.add(new Double(3.2)); //Erro: Tipo incompatvel for(Iterator i = contagem.iterator(); i.hasNext()) { Integer valor = i.next(); //No mais necessrio cast }
www.abutua.com
Cursos Abtua
84
Nota: Qualquer nome pode ser dado para os argumentos de tipo, mas a conveno usar apenas uma letra indicativa do uso do parmetro: E para element, V para value, K para key, T para type etc. Importante: A noo de tipo incompleto talvez seja uma das mais difceis para quem est comeando. Um tipo incompleto s ser interpretado pelo compilador aps o programador fornecer o argumento de tipo. Ex.: Declarao de tipo (classe/interface) incompleta: Map<K, V> Declaraes vlidas: Map<String, String>, Map<String, Empregado>, Map< Object, Object>
Note que para cada caso: Map<String, String> diferente de, por exemplo, Map< Object, Object> no so o mesmo tipo. Mesmo que K e V sejam sub/superclasses! Ex.:
List<String> frases = new ArrayList<String>(); List<Object> tudo = frases;//Erro!List<String> no List<Object>
Mtodos parametrizados Tambm possvel declarar mtodos parametrizados, mas neste caso o tipo ser deduzido/inferido automaticamente pelo compilador pela anlise dos argumentos passados nos parmetros. Os mtodos parametrizados possuem a sintaxe: <modificadores> <<argumentos de tipo>> <retorno> nome(<parmetros>) <throws>{ <declaraes> } Onde: <argumentos de tipo> a declarao dos argumentos que sero deduzidos pelo compilador, so aceitos limites superiores, mas no coringas, ex.: <T, E extends T>. <parmetros> pode conter uma mistura de argumentos de funo e argumentos de tipo <declarao> pode conter variveis que cujo tipo ser dependentes do tipo deduzido
Exemplo:
//transforma devolve um elemento de um array, no importa o tipo public <T> T getAt(T[] a, int pos) { return a[pos]; } //Data a:int[] e b:Roda[] int r1 = getAt(a, 2); //T=Integer Roda r2 = getAt(b, 1); //T=Roda
Mtodos parametrizados podem ser misturados com classes parametrizadas. Ex.:
www.abutua.com
Cursos Abtua
85
//O parmetro de tipo T ser fornecido ao instanciar a classe //O parmetro de tipo T1 ser deduzido pelo argumento t1 de bar public class Foo<T> { public <T1> void bar(T t, T1 t1) } //Vlido Foo<Integer> foo = new Foo<Integer>();//T=Integer foo.bar(new Integer(1), new Double(0.45));//T=Integer, T1=Double foo.bar(new Integer(5), new Pessoa());//T=Integer, T1=Pessoa //Invlido foo.bar(new Double(10.0), new Pessoa());//T!=Integer, T1=Pessoa
Coringas e limites
J foi mencionado que as classes parametrizadas criam um novo tipo quando completadas e que, apesar de todas as outras classes descenderem de Object, uma classe parametrizada para Foo<Object> no ser base para outras classes como Foo<String>. Sendo assim, qual o ancestral para as classes parametrizadas? Tipo Desconhecido (<?>) possvel capturar qualquer classe parametrizada atravs do uso do caractere coringa interrogao (?). Ele simboliza um tipo desconhecido (unknow). Ao se utilizar um coringa para capturar uma classe parametrizada imposta implicitamente uma restrio sobre o argumento: ele poder ser utilizado apenas para captura de leitura de valores, ou poder ser utilizado para captura de escrita, mas no ambos. A relao de classes a seguir ser utilizada em todos os exemplos: ObjectFormaRetanguloQuadrado Data uma varivel para uma coleo de tipos desconhecidos (Collection<?>) qualquer tipo parametrizado descendente de Collection satisfaz as atribuies:
List<Object> lo = new ArrayList<Object>(); List<Forma> lf = new ArrayList<Forma>(); List<Retangulo> lr = new ArrayList<Retangulo>(); List<Quadrado> lq = new ArrayList<Quadrado>(); Collection<?> c; //Coleo desconhecida //capturas c = lo; //OK c = lf; //OK c = lr; //OK c = lq; //OK
Nota: S possvel ler os elementos da coleo, e apenas como Object, nesse caso. Limite superior ou Restrio para Leitura O coringa <? extends T> limita a mnima superclasse (de T at ltimo descendente) para captura. As leituras so seguras de Object at a superclasse T. Ex.: T var = (T) conteiner.get();
www.abutua.com
Cursos Abtua
86
As escritas no so seguras, pois o tipo exato capturado desconhecido. Caso fosse possvel converter para a superclasse mais bsica (Object) poderia ocorrer a inconsistncia vista no incio desta seo. Exemplo: limitando Teto em Object
//Coleo de descendentes de Object Collection<? extends Object> co; //capturas co = lo; //OK, co = lf; //OK, co = lr; //OK, co = lq; //OK, Object descende de Object Forma descende de Object Retangulo descende de Object Quadrado descende de Object um Object ser Forma ser Retangulo ser Quadrado
//leituras Object o = c.iterator().next(); //OK, elemento Forma f = c.iterator().next(); //Erro, pode no Retangulo r = c.iterator().next();//Erro, pode no Quadrado q = c.iterator().next(); //Erro, pode no //escritas cf.add(new cf.add(new cf.add(new cf.add(new Object()); Forma()); Retangulo()); Quadrado()); //Erro, //Erro, //Erro, //Erro, no no no no seguro seguro seguro seguro
Exemplo: limitando teto em Forma
//Coleo de descendentes de Forma Collection<? extends Forma> cf; //capturas cf = lo; //Erro, Objecto no descende de Forma cf = lf; //OK, Forma descende de Forma cf = lr; //OK, Retangulo descende de Forma cf = lq; //OK, Quadrado descende de Forma //leituras Object o = cf.iterator().next(); //OK, elemento Forma f = cf.iterator().next(); //OK, elemento Retangulo r = cf.iterator().next();//Erro, pode no Quadrado q = cf.iterator().next(); //Erro, pode no //todas as escritas continuam inseguras um Objeto uma Forma ser Retangulo ser Quadrado
Exemplo: Limitando teto em Retangulo
//Coleo de descendentes de Retangulo Collection<? extends Retangulo> cr; //capturas cr = lo; //Erro cr = lf; //Erro cr = lr; //OK cr = lq; //OK //leituras Object o = cr.iterator().next(); //OK, Forma f = cr.iterator().next(); //OK, Retangulo r = cr.iterator().next();//OK, Quadrado q= cr.iterator().next();//Erro, //todas as escritas continuam inseguras elemento elemento elemento pode no um Objeto uma Forma um Retangulo ser um Quadrado
www.abutua.com
Cursos Abtua
87
Limite inferior ou Restrio para Escrita O coringa <? super T> limita a mxima subclasse (de Object at T) para captura. As leituras no so seguras alm de Object, pois o tipo exato dos elementos do continer capturado desconhecido podendo ser qualquer objeto variando de Object at T. As escritas so seguras para qualquer descendente de T. Ex.: conteiner.add((T)new Filho()); Exemplo: Limitando cho em Object
Collection<? super Object> co; //capturas co = lo; //OK, Object parente de Object co = lf; //Erro, Forma no parente de Object co = lr; //Erro, Retangulo no parente de Object co = lq; //Erro, Quadrado no parente de Object //leitura apenas de Object //escritas co.add(new co.add(new co.add(new co.add(new Object()); Forma()); Retangulo()); Quadrado()); //OK, //OK, //OK, //OK, Object um Object Forma um Object Retangulo um Object Quadrado um Object
Exemplo: Limitando de cho em Forma
Collection<? super Forma> cf; //capturas cf = lo; //OK, Object parente de Forma cf = lf; //OK, Forma parente Forma cf = lr; //Erro, Retangulo no parente de Forma cf = lq; //Erro, Quadrado no parente de Forma //leitura apenas de Object //escritas cf.add(new cf.add(new cf.add(new cf.add(new Object()); Forma()); Retangulo()); Quadrado()); //Erro, Objeto no uma Forma //OK, Forma uma Forma //OK, Retangulo uma Forma //OK, Quadrado uma Forma
Exemplo: Limitando de cho em Quadrado
Collection<? super Qadrado> cq; //capturas para escrita cq = lo; //OK, Object parente de Quadrado cq = lf; //OK, Forma parente de Quadrado cq = lr; //OK, Retangulo parente de Quadrado cq = lq; //OK, Quadrado parente de Quadrado //leitura apenas de Object //escritas cq.add(new cq.add(new cq.add(new cq.add(new Object()); Forma()); Retangulo()); Quadrado()); //Erro, Objeto no um Quadrado //Erro, Objeto no uma Forma //Erro, Retangulo no um Quadrado //OK, Quadrado um Quadrado
www.abutua.com
Cursos Abtua
88
Remoo de tipo (type erasure)

Para compatibilidade com cdigo/aplicaes anteriores verso 1.5 da linguagem Java, as verificaes de tipos de Genricos so removidas durante a execuo (as informaes esto presentes no bytecode, mas no so utilizadas durante a execuo). Exemplo:
List<Quadrado> lf = new ArrayList<Quadrado>(); Collenction<? extends Forma> paraLeitura = lf; Collenction<? super Forma> paraGravacao = lf; paraGravacao.add(new Quadrado()); Forma f = paraLeitura.iterator().next(); // executado como List lf = new ArrayList(); Collenction paraLeitura = lf; Collenction paraGravacao = lf; paragravacao.add((Forma)new Quadrado()); Forma f = (Forma) paraLeitura.iterator().next(); //---//Mistura legado + generico List<Integer> li = new ArrayList<Integer>(); List l = li; l.add(Oops); //Compilado avisa: Unchecked Warning (1) Integer i = li.iterator().next(); // executado como List li = new ArrayList (); List l = li; l.add(Oops); Integer i = (Integer) li.iterator().next(); //ClassCastException
Quando o compilador encontra uma classe no parametrizada, como as colees anteriores ao Java 5, ele no pode aplicar as verificaes de tipo. ento emitido um aviso de compilao informando que no pode verificar os tipos, e que aquele ponto do cdigo poder gerar erros de execuo. Caso o programador tenha certeza de que no haver erros (por exemplo, um cdigo intencional para compatibilidade com cdigo legado) possvel remover o aviso com o atributo:
@SuppressWarnings("unchecked")
www.abutua.com
Cursos Abtua
89
Mdulo 7 Captulo 16
Java I/O
Interfaces de Entrada e Sada na Plataforma Java

Conceito de fluxo
A Plataforma Java adota o modelo de fluxos para a representao em objetos dos mecanismos de entrada e sada (leitura e escrita) de dados. Um fluxo de dados define um canal de comunicao direcionado entre dois pontos: os dados entram (input) por uma fonte (source) e saem (output) por um destino (sink). As fontes e destinos tambm so representados como ns, e o fluxo como uma seta. Entre os fluxos de entrada e de sada podem existir objetos intermedirios que manipulam os dados antes de serem enviados para outro filtro ou destino. Por fim os objetos desenvolvidos pelo programador, ou classes de convenincia na plataforma faro uso dos filtros ou ns diretamente. Source Classe Sink
Filtros de Entrada
Filtros de Sada
A plataforma oferece vrios nveis de manipulao de dados sendo o nvel mais bsico a leitura e escrita de bytes, seguidos por caracteres (que levam em considerao mapas de caracteres e localizao regional) e serializao de objetos inteiros. Nota: A exceo bsica da maioria dos mtodos do pacote java.io IOException. Ela pode indicar um erro tanto no nvel da Java quanto um erro no nvel do sistema operacional. Nota: Todos os mtodos de leitura e escrita desta API so bloqueadores, ou seja, uma operao de leitura bloquear a thread invocadora at que existam dados para serem lidos, ou uma operao de escrita ir bloquear a thread chamadora at que todos os dados tenham sido escritos.
Manipulando bytes
Todas as classes de objetos de entrada e sada de dados herdam direta ou indiretamente da classe abstrata InputStream e OutputStream do pacote java.io. Exemplos:
www.abutua.com
Cursos Abtua
90
Base Abstrata
Ns
FileInputStream FileOutputStream
Filtros
BufferedInputStream BufferedOutputStream InputStream OutputStream FilterInputStream FilterOutputStream DataInputStream DataOutputStream ByteArrayInputStram ByteArrayOutputStram
Os mtodos bsicos de InputStream so: read():int L um byte da entrada. read(buffer:byte[]):int L at buffer.length da entrada, retorna a quantidade de bytes efetivamente lidos. read(buffer:byte[], offset:int, length:int):int L at length da entrada e escreve em buffer aps a posio offset, retorna a quantidade de bytes efetivamente lidos. Offset e length no podem ser negativos assim como length no pode ser maior que buffer.length offset. close() Fecha o fluxo e libera os recursos do sistema. avaible():int Indica se h bytes para serem lidos e quantos so.
Nota: Para todas as sobrescritas de read o retorno do mtodo int. Para o caso do primeiro mtodo (read():int) pode parecer desperdcio, mas int usado para indicar o valor -1 (0xffffffff) quando no h valor a ser lido, ou quando o fim do fluxo (se houver) foi alcanado ou quando ocorre um erro. Os mtodos bsicos de OutputStream so: write(b:int) Escreve um byte (8bits menos significantes de b). write(buffer:byte[]) Escreve buffer.length bytes de b. write(buffer:byte[], offset:int, length:int) Escreve length bytes a partir da posio offset do buffer. Offset e length no podem ser negativos assim como length no pode ser maior que buffer.length offset. close() Fecha o fluxo e libera os recursos do sistema. flush() fora a escrita dos dados na sada esvaziando, caso haja algum, buffer intermedirio.
www.abutua.com
Cursos Abtua
91
Cada uma das implementaes dos ns e filtros fornece especializaes e utilidades para trabalhar com os fluxos. Exemplo: Lendo e Escrevendo Arquivos Binrios Das operaes mais cotidianas de uma aplicao, lidar com arquivos talvez seja a mais comum. Para manipular arquivos binrios so disponibilizadas as classes FileInputStream e FileOutputStream para leitura e escrita respectivamente. Nota: Na API abordada neste captulo possvel ler e escrever num mesmo arquivo, ou seja, um mesmo arquivo pode ser referenciado por FileOutputStream e FileInputStream. No entanto responsabilidade do programador garantir que as operaes de leitura e escrita no se sobreponham (ler ou escrever um mesmo segmento), caso contrrio o resultado ser indefinido. File[Input/Output]Stream acrescentam construtores de convenincia que trabalham junto com a API de arquivos (classe File que ser discutida posteriormente). possvel abrir um arquivo informando uma String com o nome do arquivo, podendo ser apenas o nome, um caminho relativo + nome ou um caminho absoluto + nome. Tambm possvel abrir os fluxos de leitura e escrita dado um objeto de File ou de FileDescriptor. Fora os construtores, no so acrescentados mais nenhum mtodo [Input/Output]Stream. Nota: O comportamento padro de FileOutputStream de criar o arquivo (no caminho dado se existir), ser retornado uma exceo, FileNotFoundError, caso o arquivo no possa ser criado ou no possa ser aberto para escrita.
import Java.io.*; public final class Main { public static void main(String[] args) { try { OutputStream out = new FileOutputStream(teste.bin); InputStream in = new FileInputStram(teste.bin); Out.write(45); int valor = in.read(); System.out.println(valor); } catch (IOException ex) { //FileNotFoundException filho System.out.println(ex.getMessage()); } //ao sair de escopo close() chamado para ambos } } //caso no exista, cria arquivo teste.bin //imprime 45
Nota: No exemplo anterior, write escreve apenas os 8bits menos significativos do valor do argumento, ou seja, escreve apenas de 0 a 255. Caso seja passado um valor como 256 ser gravado 0 pois: 256 0x00000100. O modo de operao de File[Input/Output]Stream imediato, ou seja, cada operao de leitura ou escrita imediatamente repassada ao sistema/hardware. Quando as operaes de leitura e escrita so muito frequentes, e a quantidade lida/escrita a cada operao pequena, o custo de acessar o hardware torna-se relevante no impacto no desempenho da aplicao.
www.abutua.com
Cursos Abtua
92
recomendado utilizar espaos intermedirios de armazenamento antes de ler ou escrever no hardware. Esses espaos, chamados de buffers, quando corretamente dimensionados, melhoram a afinidade com as capacidades do hardware melhorando o desempenho da aplicao. As classes Buffered[Input/Output]Stream so filtros, ou seja, podem ser compostas com outros [Input/Output]Stream e acrescentam o gerenciamento desses espaos de armazenamento temporrio (buffers).
import Java.io.*; public final class Main { public static void main(String[] args) { try { OutputStream out = new FileOutputStream(teste.bin); InputStream in = new FileInputStram(teste.bin); OutputStream b_out = new BufferedOutputStream(out); InputStram b_in = new BufferedInputStream(in); b_out.write(45); b_out.flush();//*veja nota int valor = b_in.read(); System.out.println(valor); } catch (IOException ex) { //FileNotFoundException filho System.out.println(ex.getMessage()); } //ao sair de escopo close() chamado para ambos } }
Nota: Sem o comando b_out.flush() o resultado de b_in() seria indefinido pois a escrita (write) no efetivada enquanto o tamanho do buffer no for alcanado. Para esse exemplo o mtodo flush fora a escrita de todos os valores armazenados mesmo que o buffer ainda no tenha chegado ao limite.
Manipulando caracteres
A API de I/O de Java tambm oferece leitura e escrita de fluxos de texto (caracteres). Todos os objetos de leitura e escrita de caracteres so descendentes de Reader e Writer.
www.abutua.com
Cursos Abtua
93
Base Abstrata
Filtros
BufferedReader BufferedWriter
Ns
Reader Writer
InputStreamReader OutputStreamWriter
FileReader FileWriter
FilterReader FilterWriter
Os mtodos bsicos de Reader so: read():int L um caractere da stream read(char[] cbuf):int L at cbuf.length caracteres da stream. Retorna a quantidade de caracteres realmente lidos read(char[] cbuf, int off, int len):int L at len characters da stream os grava a partir da posio off. Retorna a quantidade de caracteres realmente lidos. Off e len no podem ser negativos e len no pode ser maior que cbuff.length off. read(CharBuffer target):int L at target.remaining(). Retorna a quantidade de caracteres realmente lidos close() Fecha o fluxo e libera os recursos do sistema. ready():boolean Indica se existem caracteres para serem lidos skip(long n):long Ignora n caracteres de entrada antes de comear a realmente ler
Os mtodos bsicos de Writer so: Os mtodos append retornam por convenincia o prprio objeto, facilitando encadear comandos em uma nica declarao. o append(char c):Writer Escreve o caractere c. o append(CharSequence csq):Writer Escreve todos os caracteres da sequencia csq. o append(CharSequence csq, int start, int end):Writer Escreve todos os caracteres da sequencia csq entre o intervalo start at end. write(char[] cbuf) Escreve todos os caracteres de cbuf write(char[] cbuf, int off, int len) Escreve len caracteres de cbuf a partir da posio off. Len e off no podem ser negativos e len no pode ser maior que cbuf.length off. write(int c) Escreve os dois bytes menos significantes de c write(String str) Escreve todos os caracteres de str
www.abutua.com
Cursos Abtua
94
write(String str, int off, int len) Escreve len caracteres da substring comeando em off. Len e off no podem ser negativos e len no pode ser maior que cbuf.length off. close() Fecha a stream e libera os recursos associados flush() Fora a escrita dos dados
Exemplo: Lendo e Escrevendo Arquivos de Texto Assim como para as streams binrias, a API de Java oferece classes similares para suporte em modo texto. Todas as notas anteriores tambm se aplicam para a API de caracteres. Internamente Java utiliza caracteres UNICODE, a API de I/O de caracteres utiliza internamente as interfaces binrias aplicando as converses necessrias para transformar a representao interna na representao da plataforma e vice-versa. Por exemplo, para escrever ou ler um arquivo de texto no Microsoft Windows PT-Br feita a converso de/para latin-1 (Windows Europeu Ocidental). As converses so transparentes, mas caso o programador necessite de maior controle sobre as converses de representao de caracteres necessrio lidar com a API de Localizao Java. A ponte entre o fluxo de bytes e o fluxo de caracteres so as classes InputStreamReader e OutputStreamWriter.
import Java.io.*; public final class Main { public static void main(String[] args) { try { Writer out = new FileWriter(teste.txt); Reader in = new FileReader(teste.txt); out.append(Ol).append( ).write(Mundo); out.flush(); in.skip(3); char[] temp = new char[5]; in.read(temp); System.out.println(temp); } catch (IOException ex) { //FileNotFoundException filho System.out.println(ex.getMessage()); } //ao sair de escopo close() chamado para ambos } } //caso no exista, cria arquivo teste.txt //imprime Mundo
Nota: No exemplo acima a escrita esta sendo feita em uma nica declarao pois append retorna o prprio objeto. As Strings so automaticamente convertidas para CharSequence. E finalmente out.flush() foi chamado para garantir a escrita (algumas plataformas podem fazer cache para arquivos de texto, sempre recomendado executar flush quando se necessita ter certeza que os dados foram escritos na sada). Formatao Apesar da API de leitura e escrita de caracteres tambm fornecer classes para manipulao com buffers, mais comum manipular textos em um nvel mais alto.
www.abutua.com
Cursos Abtua
95
BufferedReader oferece um primeiro nvel de convenincia com o mtodo BufferedReader.readline():String. Esse mtodo l caracteres do fluxo at encontrar um caractere de nova linha (independente de plataforma), ou at o fim do arquivo (EOF) retornando uma String a cada chamada, ou null se j tiver alcanado o fim do arquivo. PrintWriter oferece diversos mtodos de escrita e formatao. Ela possui todos os mtodos de PrintStream (que a classe utilizada em System.out e System.err), mas seu construtor trabalha com fluxos de texto formatado (Writer e descendentes). Nota: System.in um objeto de InputStream, ou seja, binrio. System.out e System.err so objetos de PrintStream, ou seja, alm de oferecerem acesso binrio tambm oferecem as facilidades de formatao de texto mas essencialmente continuam binrios. Melhorando o exemplo anterior:
Reader in = new FileReader(teste.txt); BuferedReader b_in = new BufferedReader(in); Writer out = new FileWriter(teste.txt); PrintWriter p_out = new PrintWriter(out); p_out.flush(); p_out.format(%d: %s%nHello, 1, Main.class); String linha = b_in.readLine(); System.out.println(linha); //imprime 1: class Main
Nota: Deve-se tomar cuidado com BufferedReader.readLine() pois ele pode travar a aplicao (deadlock), por exemplo, se fosse utilizado com um socket cujo fim do arquivo desconhecido, readLine no conseguiria retornar. Tanto Print[Writer/Stream] quanto String possuem um mtodo chamado format (por convenincia tambm existe printf no caso de Print[Writer/Stream]) que um atalho para a classe Formater. Essa classe recebe, basicamente, uma String especialmente montada e um array de objetos que sero transformados em texto e colocados na string. A String de formatao contm sequencias especiais que indicam onde os objetos argumentos sero escritos. Do exemplo anterior: %d indica que ser escrito um dgito numrico %f indica que ser escrito um dgito decimal %s indica que ser escrito um texto %n um comando especial para imprimir um caractere de nova linha (dependente do sistema)
A formatao das sequencias especiais segue a forma: %d$fw.pc Onde:
www.abutua.com
Cursos Abtua
96
% o incio da sequencia d$ o ndice do argumento (0 a prpria string de formatao, 1 a N so os outros objetos). opcional e caso no seja especificado, cada sequncia corresponder a um argumento respectivamente. f so flags, marcaes de como formatar, posicionar e preencher. w o tamanho reservado para a substituio (incluindo separadores decimais, casas decimais, etc) .p um nmero indicativo da preciso das casas decimais. c converso, indica qual a classe do objeto de origem (f para decimal, d para dgito, s para texto, etc) Para escrever o smbolo % pasta duplic-lo: %%
Serializao
Definido os mecanismos bsicos para ler e escrever em fluxos de dados binrios e de caractere torna-se interessante ter ferramentas para automatizar a leitura e escrita de objetos inteiros. A Framework do Java oferece mecanismos (APIs) que facilitam a leitura e escrita para os tipos primitivos e para os tipos de referncia (objetos). Essas APIs so representadas por DataStream e ObjectStream. Fluxo de dados (DataStream)
Interface DataInput Interface DataOutput
DataInputStream
DataOutputStream
DataInputStream e DataOutputStream so as implementaes padro de DataInput e DataOutput especificamente. Elas so ns filtros, ou seja, encapsulam um objeto como, por exemplo, FileOutputStream. Para cada tipo primitivo boolean, char, byte, short, int, long, float e double, existe o mtodo correspondente DataOutput.writeXXX e DataInput.readXXX. Exemplos: DataOutput.writeChar(char c), DataOutput.writeByte(byte b), DataOutput.writeLong(long l) etc. Essas duas classes ajudam na implementao de interfaces com protocolos de comunicao, binrios ou de texto ou uma mistura de ambos, ou para ler/escrever em arquivos especficos (que possuem um padro como jpeg e mp3). Entretanto DataOutput possui trs mtodos para escrever Strings que possuem comportamentos distintos:
www.abutua.com
Cursos Abtua
97
writeBytes(String) escreve tantos bytes quantos forem os caracteres da String, so escritos apenas os 8bits menos significativos de cada caractere. Recomendado para textos cujos caracteres estejam dentro de ASCII. writeChars(String) escreve dois bytes para cada caractere da String. Sendo primeiro byte escrito o byte de menor significado: 0x0000 AA(2) BB(1) writeUTF(String) escreve primeiramente 2 bytes com o tamanho da String seguido por uma quantidade varivel de bytes que depende de cada caractere, seguindo as regras do UTF-8 modificado (nota: possui contraparte DataInput.readUTF()).
J a interface DataInput possui mtodos de convenincia para ler inteiros sem sinal de 8 e 16 bits (de ISO C/C++: u_int8 e u_int16, por exemplo), nesse caso como a linguagem Java no suporta inteiros de 8 e 16 bit sem sinal eles so convertidos para int.
//Lendo o cabealho de um arquivo DataInput di = new DataInputStream(...); //2 primeiros byte devem ser sempre 0 e 1 if(di.readByte() == 0 && di.readByte() == 1) { //1 valor: inteiro com o tamanho do arquivo long fileSize = di.readLong(); //2 valor: String de 2 letras (bm) String tipoImagem = di.readLine(); //2 inteiro o tamanho da imagem int size = di.readInt(); //Le os bytes da imagem byte[] img = new byte[size]; di.readFully(img); }
Fluxos de Objetos (ObjectStream)
Interface DataInput Interface DataOutput
Interface ObjectInput Interface ObjectOutput
ObjectInputStream
DataOutputStream
A API de Serializao de Java permite ler e escrever em streams objetos inteiros de forma automatizada, incluindo referncias a outros objetos dentro do objeto serializado (deepsearch). Outra peculiaridade da serializao de objetos a no duplicao dos objetos: caso seja gravado duas vezes o mesmo objeto na stream, o objeto em si ser salvo apenas uma vez e o segundo objeto ser uma referncia para o primeiro. Ex.:
ObjComplexo cplx1 = new ObjComplexo(); ObjComplexo cplx2 = cplx1; ObjectOutput oo = new ObjectOutputStream(...); oo.writeObject(cplx1); oo.writeObject(cplx2);//obj. no duplicado, salva referncia
www.abutua.com
Cursos Abtua
98
Nota: Nem todos os objetos podem ser serializados, para garantir a consistncia da operao todos os objetos serializveis devem conter apenas tipos primitivos ou outros objetos que tambm sejam serializveis. Essa capacidade indicada atravs da implementao da interface Serializable. Importante: A serializao dos objetos intrnseca plataforma/linguagem. Isto quer dizer que um objeto Java serializado s pode ser lido por outra aplicao Java (aplicada as devidas limitaes de verses). A troca de objetos agnstica de plataforma/linguagem possvel atravs de outras implementaes de Object[Read/Write] como XMLRPC e CORBA.
Sistema de Arquivos
Aviso: Esta apostila est formatada para a verso Java 6 da API de Sistema de Arquivos. Essa API foi drasticamente revisada e ampliada na verso Java 7. A principal classe para lidar com o sistema de arquivos java.io.File. Essa classe representa um recurso da plataforma na qual a JVM est sendo executada. Esse recurso pode ser um arquivo ou um diretrio (ou pasta). Os sistemas de arquivos so estruturas hierrquicas para organizar logicamente conjuntos de dados. Esses dados so arquivos como aplicaes, imagens, sons etc. Os arquivos so os ns finais, ou folhas, da rvore de diretrios, sendo esses ltimos ns nomeados que levam a outros ns intermedirios ou aos arquivos. J foram vistos nas sees anteriores como Java mapeia os arquivos de classes e a estrutura de pacotes com os arquivos e pastas do sistema de arquivos. Limitaes Algumas das limitaes da API de Sistema de Arquivos presentes at a verso Java 6 que devem ser levadas em considerao: A maioria dos mtodos no emite excees caso ocorra um erro. o Por exemplo, quando a leitura de arquivo falha no possvel saber se falhou porque o arquivo no existia, se o usurio no tinha permisso ou se o arquivo j estava aberto em modo exclusivo. O mtodo rename possui comportamento diferente para diferentes plataformas. No h distino entre um arquivo real e um link para arquivo (symbolic link). o Sem essa distino no h como escrever cdigos simples de listagem de diretrio recursivos quando h links simblicos cclicos (circular symlink) Suporte amplo metadados, como permisses, grupos de acesso, nveis de segurana etc. o Acesso padronizado aos atributos Implementao eficiente/escalvel o A API atual pode causar travamentos e falta de memria ao listar rvores muito grandes ou ainda remotas (distributed file system)
www.abutua.com
Cursos Abtua
99
java.io.File A classe java.io.File o ponto central (hub) que concentra todas as tarefas para interao com o sistema de arquivos. A representao de caminhos (diretrios) dependente do sistema. Os sistemas derivados de Unix usam / representar o diretrio raiz e como separador de diretrios e : como separao de caminhos. Ex.: /usr/bin:/user/foo/.ssh Os sistemas Windows utilizam \\\\ como raiz para caminhos UNC (Universal Naming Convention), ou uma letra de unidade seguida de : para recursos locais. Em ambos os casos, utiliza-se \\ como separador entre diretrios. A separao entre caminhos feita com ;. Ex.: \\machine01\shared;C:\windows\system Nota: que como \ utilizada como caractere de escape em Strings da linguagem Java, necessrio duplic-lo para obter o smbolo correto: \\ \ Os caracteres de separao de diretrios e de caminhos esto disponveis respectivamente pelos campos de classe: File.separator:String e File.separatorChar:char File.pathSeparator:String e File.pathSeparatorChar:char
Os caminhos relativos podem ser escritos utilizando a notao nativa da plataforma (como visto anteriormente) ou preferencialmente apenas a notao /. Caminhos relativos comeam diretamente com um nome que pode ser um caminho ou o nome de um arquivo. Ex.:
//Funciona para qualquer plataforma File f1 = new File(tmp/az001rts/oob.bin); File f2 = new File(teste.txt); //Funciona apenas para plataforma especfica File f3 = new File(images\\logo.gif);
Os caminhos relativos tomam como referncia o local aonde a JVM foi executada (caminho base). Por exemplo, caso o sistema seja um Windows e o Java tenha sido executado em C:\windows\system32\java.exe o caminho base ser C:\\windows\\system32\\. Para a declarao:
File f = new File(temp\foo.tmp); System.out.println(f.getAbsolutePath()); //imprime: C:\windows\system32\temp\foo.tmp
Nota: O objeto File imutvel, ou seja, cada instncia representa apenas um arquivo ou caminho. Os mtodos que retornam File o fazem com novas instncias. Para ambos os sistemas, um caminho relativo tambm pode utilizar os caracteres .\ para representar o caminho atual e ..\ para o diretrio imediatamente superior. Para remover esses smbolos especiais deve-se utilizar o mtodo getCanonicalPath():String. Ex.:
www.abutua.com
Cursos Abtua
100
//Este exemplo fora um caminho base diferente do padro //O caminho relativo pode sempre utilizar / //File(caminho base, caminho/arquivo relativo); File f = new File(C:\\Users\\Pedro\\Documents, ../Downloads/file.j); System.out.println(f.getAbsolutePath()); //> C:\Users\Pedro\Documents\..\Downloads\file.j System.out.println(f.getCanonicalPath()); //> C:\Users\Pedro\Downloads\file.j
Interfaces de java.io.File Uma amostra dos mtodos de File: Inferncia (todos retornam booblean) o canExecute Retorna verdadeiro se File apontar para um arquivo, e esse arquivo existir e se existe permisso de execuo. o canRead Retorna verdadeiro se File apontar para um arquivo, e esse arquivo existir e se existe permisso de leitura. o canWrite Retorna verdadeiro se File apontar para um arquivo, e esse arquivo existir e se existe permisso de escrita. o exists Retorna verdadeiro se File apontar para um arquivo ou caminho e ele existir. o isAbsolute Retorna verdadeiro se File apontar para um caminho, e ele existir e ser absoluto. o isDirectory Retorna verdadeiro se File apontar para um caminho e ele existir o isFile Retorna verdadeiro se File apontar para um arquivo, e ele existir o length():long Retorna o tamanho do arquivo em bytes caso seja um arquivo. Indefinido caso no seja um arquivo, ou seja um arquivo especial como um Pipe Manipulao o createNewFile():boolean Tenta criar o arquivo representado (se ele j existir retorna falso) o [esttico]createTempFile():File Cria um arquivo temporrio no diretrio padro ou no diretrio dado com o prefixo e sufixo dados o delete():boolean Tenta remover o arquivo ou diretrio o deleteOnExite [Cuidado] marca o arquivo ou caminho para tentar deletar ao trmino da JVM o mkdir(): boolean Tenta criar o diretrio indicado o mkdirs():boolean Chama recursivamente mkdir e tenta criar toda a estrutura de diretrios (at a raiz do caminho absoluto) o renameTo(f:File):boolean Tenta renomear o arquivo para o arquivo dado Interao o getName():String retorna o caminho representado pelo objeto o getPath():String retorna o caminho representado pelo objeto na forma nativa o list():String[] Retorna uma lista dos arquivos e diretrios do caminho representado pelo objeto.
www.abutua.com
Cursos Abtua
101
Mdulo 7 Captulo 17
Java Threads
Interfaces de Processamento Concorrente (Threads)

Essa seo ir tratar dos objetos, mtodos e interfaces bsicos para interao com mltiplos processos e linhas de execuo (threads) da API de Concorrncia do Java e o sistema operacional.
Processos e Threads
Na arquitetura moderna de sistemas operacionais, o ambiente de execuo composto por vrios processos e threads sendo executados concorrentemente, possivelmente at simultaneamente para sistemas com mltiplos ncleos ou distribudos. Um processo um ambiente de execuo contido. Ele possui descritivos de execuo, uma reserva de memria, permisses, um conjunto de variveis de ambiente etc. Uma aplicao no precisa ser necessariamente um processo, pois uma aplicao pode utilizar-se de outros subprocessos, ou processos filhos, para executar suas tarefas. Todo processo possui uma linha de execuo principal chamada de Main Thread que comea sua execuo pelo mtodo main. Assim como uma aplicao pode fazer uso de vrios processos, um processo pode criar vrias linhas de execuo que sero filhas de Main Thread. Como cada processo isolado, a comunicao entre processos d-se por mecanismos especiais de Comunicao Inter Processos (IPC), como arquivos pipe e sockets. Como as threads residem dentro de um mesmo processo, no necessrio mecanismos de comunicao, mas de controle de acesso memria, que pode ser compartilhada para comunicao. Aplicao IPC Processo Principal Thread Main Threads Secundrias Nota: Apesar das novas threads estarem associadas a thread principal, a finalizao desta ltima no ocorre at que todas as threads secundrias tambm tenham terminado. Processo Secundrio Processo Secundrio Processo Remoto
www.abutua.com
Cursos Abtua
102
Estados
Uma thread representa um elemento ativo, ela representa o processador executando as declaraes do programa. Na a execuo concorrente existem vrias threads que dividem o uso do processador compartilhando por tempo, ou seja, cada thread executa por uma determinada quantidade de tempo e cede sua vez (voluntaria ou involuntriamente) para que outra thread possa executar suas tarefas. Para saber a situao de uma thread no tempo existem estados que uma thread pode assumir. So eles: Bloqueada 5 3 1 Pronto Executando 2 4 6 1. 2. 3. 4. 5. 6. incio execuo pausa evento/IO desbloqueio terminada
As threads so agrupadas em filas, ordenadas pelo seu estado. So trs estados principais: Pronto, Executando e Bloqueado. Aps serem criadas13, as threads so marcadas como prontas para execuo (1). Ao entrarem no processador so marcadas como executando (2), essa tarefa feita pelo sistema operacional por um agendador (scheduler). Durante o seu tempo de vida, uma thread oscilar entre executando e pronta diversas vezes, voluntria (ex.: Thread.yield) ou involuntariamente (2 e 3). Quando uma thread requisita um acesso externo, por exemplo, a leitura ou escrita de um arquivo (operao de IO), ou um evento como um contador (ex.: Thread.wait), a thread vai para uma fila de estado bloqueado (4). Quando a operao termina ou o evento ocorre, a thread retirada da fila de bloqueio e volta para o estado de pronta (5). Uma thread executa uma funo, ou mtodo neste caso. Quando a funo acaba a thread chega ao fim e removida do agendador (6). Nesse caso dito que a thread terminou normalmente (gracefully). Porm uma thread tambm pode ser forada a terminar, seja por uma exceo no capturada ou foradamente (ex.: Thread.interrupt).
public class TesteCaso implements Runnable{ private final byte[] valores = {0x21, 0x16, 0xAB, ...}; private OutputStream out; ... @Override public void run() { //Entra em run(): (2)
13
A criao do objeto Thread feito com o operador new. A thread em si, elemento do processador, criada ao executar o mtodo Thread.start().
www.abutua.com
Cursos Abtua
103
for(byte b: valores) { out.write(b);//Entra em write: (4) //volta de write: (5) }//cada interao do loop significa volta execuo: (2) ... //durante outras linhas haver pausas: (3) <-> (2) }//fim de run(): (6) } ...em algum lugar da aplicao ... //cria thread p/ agendador: (1) (new Thread(new TesteCaso())).start();
Classes e Interface
Como uma linguagem orientada a objetos, Java representa uma threads como objetos atravs da classe Thread. Essa por sua vez implementa a interface Runnable. A classe Thread possui os mtodos e campos necessrios para se obter informaes sobre thread como seu identificador (quando a thread existe no processador), informao de interrupo, valor de retorno, estado, mtodos de espera (wait), descanso (sleep), cooperao (join) etc. O principal mtodo de Thread start():void. Este mtodo agenda uma thread real para ser executada, ou seja, coloca uma thread em estado de Pronto. Nota: Uma segunda chamada ao mtodo Thread.start():void emite uma exceo IllegalThreadStateException, pois cada objeto Thread pode monitorar uma thread por vez. Ao iniciar uma thread necessrio associar uma funo. Na linguagem Java as threads criadas so associadas ao mtodo run():void da interface Runnable. Existem duas formas de se programar novas threads. A primeira herdar Thread como classe base e sobrescrever Thread.run():void, a desvantagem dessa abordagem limitar as possibilidades de programao pois s possvel herdar de uma nica classe. A segunda forma implementar a interface Runnable, a desvantagem dessa forma ter de criar explicitamente um objeto Thread ou fornecer um mtodo fbrica.
//Exemplo com herana public class MalaDireta extends Thread { private Collection<String> emails; @Override public void run() { for(String email: emails) { enviarPropaganda(email); } } ... public static void main(String[] args) { ... MalaDireta md = new MalaDireta(); md.setEmails(...); md.start(); //neste ponto criada uma nova thread
www.abutua.com
Cursos Abtua
104
//que enviar as propagandas ... outrasTarefas(); //start() retorna imediatamente //a nova thread corre em paralelo ... md.join(); //aguarda pela thread de propaganda antes de //de terminar (boas praticas) } } //Exemplo com interface public class MalaDireta extends ProtoEmail implements Runnable { @Override public void run() { ... } public static void main(String[] args) { ... MalaDireta md = new MalaDireta(); md.setEmails(...); //thread agora deve ser explicita Thread t1 = new Thread(md); t1.start(); //neste ponto criada uma nova thread //que enviar as propagandas ... outrasTarefas(); //start() retorna imediatamente //a nova thread corre em paralelo ... t1.join(); //aguarda pela thread de propaganda antes de //de terminar (boas praticas) } }
Nota: Os construtores de Thread oferecem suporte para nomear uma thread (atravs de uma String), til para debug. Tambm oferece suporte para agrup-las logicamente em objetos de ThreadGroup, til para sistemas de vrios ncleos (ex.: Oracle SPARC T4 8x8, 64threads).
Sincronizao entre Threads

Uma thread est associada a um mtodo inicial. Durante seu tempo de vida, uma thread pode visitar tantos mtodos quanto o algoritmo descrever. Como um algoritmo pode ser visitado por diversas threads14, torna-se necessrio um mecanismo para, primeiramente, identificar a thread em operao e ento operaes para sincronizar, caso necessrio, o fluxo de execuo das mesmas. A interface de Thread: getId():long Retorna o identificador da thread. getPriority():int Retorna o nvel de prioridade da thread. setPriority(newPriority:int) Muda o nvel de prioridade da thread. getState():Thread.State Retorna o estado da thread. interrupt() Se a thread estiver em wait(), join() ou sleep(), interrompe a thread com a exceo InterruptedException e seta o campo interrupted para falso. Caso contrrio seta o campo interrupted para true. permitido que uma thread interrompa a si mesma. (nota: Possui outros comportamentos para objetos especiais de IO)
14
Um mtodo que compartilhado por diversas threads chamado de reentrante.
www.abutua.com
Cursos Abtua
105
isInterrupted(): boolean Testa se o campo interrupted da thread true, no muda o estado do campo interrupted. Feito para uma thread consultar o estado de interrupo de outra. start() Cria uma thread no sistema e a coloca na fila para execuo. isAlive(): boolean Testa se a thread est ativa (pronta, executando ou bloqueada). join(...) Espera, indefinidamente ou temporariamente, pelo fim da thread referenciada, ou seja, faz com que a thread corrente espere pelo fim da thread referenciada. [sttico] currentThread(): Thread Obtm uma referncia da thread que est executando o cdigo corrente. [sttico] interrupted():boolean Testa se o campo interrupted da thread corrente true e depois muda seu estado para false. Feito para ser consultado explicitamente antes de executar um wait/join/sleep evitando lidar com exceo. [sttico] sleep(...) Faz com que a thread corrente pare (bloqueie) por um determinado tempo. [sttico] yield() Faz com que a thread corrente "desista" e volte para a fila de pronto dando a vez da execuo para a prxima thread.
Nota: Os mtodos que recebem tempo como parmetro podem ser especificados em mili (1 argumento) e nano segundos (2 argumento), no entanto a preciso depende da plataforma e sistema operacional.
public class Soneca implements Runnable { private Boolean dormindo; @Override public void run() { try { //Soneca tenta dormir por 1hora antes de trabalhar dormindo = true; Thread.sleep(3600000); }catch(InterruptedException e) { // -.} finally { dormindo = false; //faz trabalho ... } } public Boolean isDormindo() { return dormindo; } } ... public static void main(String[] args) {//thread Main Soneca soneca = new Soneca(); //cria uma nova thread e Coloca soneca como responsvel Thread trabalho = new Thread(soneca); //Manda soneca comear a trabalhar trabalho.start();
www.abutua.com
Cursos Abtua
106
Teste #1: confiar em soneca e esperar que ele termine.

trabalho.join(); // a thread Main s vai acabar daqui 1 hora... }
Teste #2: interromper o sono de soneca.

if(soneca.isdormindo()) trabalho.interrupt(); trabalho.join(); //a thread Main agora ir acabar assim que o trabalho acabar }
Nota: Sem o try-catch em Soneca, a exceo iria vazar para a thread Main. Sincronizao Devido a natureza preemptiva da execuo de threads, no h garantia da execuo completa (do incio ao fim) de todas as declaraes de um algoritmo por uma nica thread, ou seja, num algoritmo aonde diversas threads esto executando o mesmo cdigo, pode haver situaes corrida, aonde uma thread A altera o valor de um campo x que acabou de ser escrito por uma thread B que iria precisar do valor anterior. Para coordenar o acesso das threads para os objetos ou valores compartilhados, a plataforma Java utiliza o conceito de monitores. Cada objeto em Java possui um monitor. Um monitor funciona como uma espcie de trava (lock). Quando uma thread adquire um monitor ela fecha o objeto para que apenas ela possa alterar seu estado (campos), todas as outras threads que tambm precisem alterar o objeto bloqueiam aguardando a liberao do monitor. Esse comportamento chamado de excluso mtua. O mecanismo synchronized utilizado para limitar o acesso simultneo das threads ao objeto adquirindo e travando o monitor. Synchronized pode ser um modificador para ser aplicado aos mtodos do objeto. Um mtodo sincronizado bloqueia o objeto this durante toda a execuo do mtodo, ou seja, quando uma thread chama um mtodo sincronizado, apenas ela ter acesso exclusivo aos campos do objeto e ao monitor.
public class Padaria { public synchronized Pao getPao() { ... } } //thread 1 padaria.getPao();// requisita bloqueio do objeto padaria //thread 2 Padaria.getPao();// aguarda thread 1 terminar
Synchronized tambm pode ser uma declarao para bloquear um objeto especfico e proteger um conjunto de instrues que sero aplicadas a esse objeto. Todos os campos e mtodos declarados dentro do bloco sincronizado so acessados por apenas uma thread.
www.abutua.com
Cursos Abtua
Preparatrio para Certificao Java synchronized(<objeto a ser sincronizado>) { <declaraes> }
107
Nota: Synchronize indicado para algoritmos aonde no haja necessidade de bloquear todo o objeto durante toda a execuo da tarefa.
//Usando synchronied(this) desta forma: public void metodoSync() { synchronized(this) { ... } } // equivalente a: public synchronized void metodoSync() { ... } //Caso no seja necessrio bloquear por toda a execuo: public void metodoSync() { ... fazerTarefa(); fazerOutraTarefa(); ... synchronized(this) { //tarefa que no pode ser compartilhada/interrompida ... } maisTarefas(); }
A sincronizao dos objetos tambm pode ser feita manualmente com os mtodos wait e notify de Object: wait(...) Coloca a thread corrente em estado de espera, por tempo determinado ou indeterminado, liberando o monitor. notify Acorda uma thread que esteja aguardando pelo monitor. notifyAll Acordas todas as threads que estejam aguardando pelo monitor.
Nota: O mtodo wait deve ser utilizado preferencialmente em loops, transformando a espera ativa em passiva (economizando recursos de processamento). Nota: Tanto wait quanto notify e notifyAll devem ser utilizados dentro de blocos ou mtodos sincronizados ou ser emitida a exceo IllegalMonitorStateException. Essa requisio se deve s mudanas e otimizaes feitas desde a verso 1.5 da Plataforma Java
//Loop de espera ativa //dado que pronto:boolean public void synchronized consumidor() { //adquire monitor this ... while(!pronto) { //torra processador! } fazTarefa(); ...
www.abutua.com
Cursos Abtua
}
108
//Loop de espera passivo public void synchronized consumidor() { //adquire monitor this ... While(!pronto) { try{ // espera 10seg. antes de tentar novamente wait(10000); // e libera monitor this //readquire monitor aps 10seg. } catch (InterruptedException e) { } } fazTarefa(); ... }
Exemplo similar a Thread.join():

public class Main { //classe interna public static class Foo implements Runnable { //mtodo run coloca thread para dormir por 5seg. Aps tempo //notifica outras threads que estejam aguardando pelo mesmo //objeto @Override public void run() { try { Thread.sleep(5000); } catch(InterruptedException ex) { } finally { synchronized(this) { //adquire monitor deste objeto notifyAll(); //marca monitor como liberado e } //solta monitor } } } public static void main(String[] args) { Foo f = new Foo();//cria objeto de Foo (new Thread(f)).start();//inicia nova Thread e executa run try { synchronized(f) { //adquire monitor da instancia de Foo f.wait(); //solta monitor e aguarda por notify } } catch (InterruptedException ex) { } //imprime esta linha aps 5seg. System.out.println("tah-tah!"); } }
www.abutua.com

Apostila pcj-n1

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

Apostila pcj-n1

Enviado por

Direitos autorais:

Formatos disponíveis

www.abutua.

Preparatrio para Certificao Java

Preparatrio para Certificao Java

Preparatrio para Certificao Java

Preparatrio para Certificao Java

Preparatrio para Certificao Java

Preparatrio para Certificao Java

Preparatrio para Certificao Java

Preparatrio para Certificao Java

Preparatrio para Certificao Java

Aplicao Java APIs: Colees, Swing, Sockets etc

Arquivos Compilador .java

Interpretador Class Loader

Preparatrio para Certificao Java

5. Execute a aplicao atrvs do lanador (ex.: java.exe)

6. Dever ser impresso no janela do prompt de comandos

Preparatrio para Certificao Java

Arquivo Hello.java class Hello { Arquivo Janela.java class Janela { ...

O que pode dar errado

Preparatrio para Certificao Java

A programao de aplicaes composta por duas etapas:

Preparatrio para Certificao Java

Preparatrio para Certificao Java

Por simplicidade, atores e objetos so ambos tratados apenas como objetos.

Preparatrio para Certificao Java

<modificador>* <tipo> <nome> [= <valor>];

<modificador>* <tipo_retorno> <nome> (<argumentos>*) { <declaraes>* }

[<modificador>] <nome_da_classe> (<argumentos>*) { <declaraes>* }

Preparatrio para Certificao Java

Preparatrio para Certificao Java

Operador ponto (.)

Ateno: apenas permitido um modificador de acesso por classe ou membro. Exemplos:

Quando o modificador de acesso omitido, pacote ser o nvel de visibilidade padro.

Preparatrio para Certificao Java

Preparatrio para Certificao Java

Acessores get, set, is, has

[tipo_do_campo] get[NomeDoCampo]() void set[NomeDoCampo]([tipo_do_campo][nome])

boolean is[NomeDoCampo]() boolean has[NomeDoCampo]()

Preparatrio para Certificao Java

Onde: Decalrao do pacote possui a sintaxe:

Preparatrio para Certificao Java

Para importar todas as classes de um pacote:

Preparatrio para Certificao Java

Preparatrio para Certificao Java

} //c no existe no bloco exterior a = 10; }

Preparatrio para Certificao Java

Funes, Mtodos ou Procedimentos

Cursos Abtua Exemplos:

Preparatrio para Certificao Java

Passagem por Valor e passagem por referncia

Preparatrio para Certificao Java

Preparatrio para Certificao Java

Tipos Primitivos ou Bsicos

Inteiros e Ponto Flutuante

Preparatrio para Certificao Java

Preparatrio para Certificao Java

Preparatrio para Certificao Java

Preparatrio para Certificao Java

Criando um objeto novo

Preparatrio para Certificao Java

Para acessar os valores do conjunto utiliza-se o operador ponto (.):

Preparatrio para Certificao Java

Acessando os Elementos por ndices

<modificador>* <tipo_retorno> <nome> (<argumentos>) { <declaraes> }

[<modificador>] <nome_da_classe> (<argumentos>) { <declaraes> }