You are on page 1of 44

Universidade Católica do Salvador

Estrutura de Linguagens

Davi Lourenço José Adauto Luis Cláudio Maira Galindo Sidney Reis

SALVADOR – 2007

Davi Lourenço José Adauto Luis Cláudio Maira Galindo Sidney Reis

Estrutura de Linguagens

Trabalho apresentado à Universidade Católica do Salvador referente à matéria Estrutura de Linguagens.

SALVADOR – 2007

RESUMO DO TRABALHO
Este trabalho tem o objetivo de mostrar um estudo realizado sobre a linguagem de programação JAVA no que se refere ao seu histórico, modelo, tipificação e aplicabilidade, bem como critérios para sua avaliação, recursos nativos, controle e gerenciamento de exceção e programação concorrente de acordo com o que foi visto na matéria Estrutura de Linguagens. Este estudo não tem preocupação com a implementação da linguagem, porém possui trechos de códigos de programas nesta linguagem apenas de caráter explicativo para facilitar o entendimento como um todo.

SUMÁRIO
VISÃO DO PROJETO......................................................................................................5 1.1.HISTORICO E APLICATIBILIDADE DA LP JAVA...............................................5 1.2.MODELO DALINGUAGEM JAVA..........................................................................6 1.3.MODELOS DE EXECUÇÃO. AVALIAÇÃO DA LINGUAGEM EM RELAÇÃO AOS CRITÉRIOS..............................................................................................................7 1.4.MECANISMOS QUE FACILITEM A PRODUÇÃO DEPROGRAMAS QUE ATENDAM AS SUAS ESPECIFICAÇÕES....................................................................8 1.5.FUNCIONAMENTO DO AMBIENTE DE GERAÇÃO DE CÓDIGO E EXECUÇÃO DE PROGRAMAS.....................................................................................9 1.6.FUNCIONAMENTO DO AMBIENTE DE GERAÇÃO DE CÓDIGOS E EXECUÇÃO DE PROGRAMAS.....................................................................................9 Sistema de Tipos em Java................................................................................................10 A linguagem Java oferece diversos tipos de dados que podem ser classificados basicamente em duas grandes categorias: tipos primitivos e tipos de referências (estruturados homogêneos e heterogêneos). ...............................................................11 As características dos tipos de dados primitivos independem da plataforma em que o programa deverá ser executado. Dessa forma, possibilita sua portabilidade entre diversos tipos de computadores, minimizando o esforço do desenvolvedor com a tarefa de conversão de dados em formatos apropriados para a portagem. .................11 Tipo Boolean...............................................................................................................12 Este é o tipo de dado mais simples encontrado em Java. Uma variável booleana pode assumir apenas um entre dois valores: true ou false. Algumas operações possíveis em Java como a<=b e x>y têm como resultado um valor booleano, que pode ser armazenado para uso futuro em variáveis booleanas. Estas operações são chamadas operações lógicas.........................................................................................................12 Tipos de dados inteiros................................................................................................12 Os tipos de dados primitivos byte, int, char, short e long constituem tipos de dados inteiros. Isso porque variáveis desses tipos podem conter um valor numérico inteiro dentro da faixa estabelecida para cada tipo individual................................................12 TIPOS ESTRUTURADOS..............................................................................................13 Vetores e Matrizes ......................................................................................................13 A utilização de vetores e matrizes em Java envolve três etapas: declarar do vetor ou matriz; reservar de espaço de memória e definir d tamanho e armazenagem de elementos. ...................................................................................................................14 2.AMBIENTE DE NOMES............................................................................................20 3.1.ASSOCIAÇÃO: AMARRAÇÃO, VINCULAÇÃO (BINDING).............................20 3.2.VINCULAÇÃO ESTÁTICA E DINÂMICA............................................................22 3.3.DURAÇÃO E GERENCIAMENTO DE MEMÓRIA..............................................24 3.4.DURAÇÃO, ALCANCE E VISIBILIDADE...........................................................25 3.TRATAMENTO DE EXCEÇÕES...............................................................................26 4.1.SISTEMA DE TRATAMENTO DE EXCEÇÕES...................................................26 4.2.HIERARQUIA DE EXCEÇÕES..............................................................................28 4.3.FLUXO DE EXECUÇÃO NORMAL E EXCEPCIONAL......................................29 4.4.EXCEÇÕES DEFINIDAS PELO USUÁRIO...........................................................30 4.TRATAMENTO DE EXCEÇÕES...............................................................................31 4.5.SISTEMA DE TRATAMENTO DE EXCEÇÕES...................................................31 4

............... A linguagem de programação Java por ser projetada para ser pequena........................2. Por isso Java é mais rápida do que se fosse apenas interpretada e é portável..................................37 O programa geralmente não possui controle sobre a ordem e o tempo de execução das unidades concorrentes......37 Concorrência relaciona-se com fluxo de controle: em um programa...............O QUE SÃO THREDS E PARA QUE SERVEM ESSAS THREDS?.... caiu no gosto dos programadores............................................ e foi chamada de OAK (carvalho visto da janela de seu escritório).......HIERARQUIA DE EXCEÇÕES..........8........38 5......... Execução concorrente..............................37 A execução de unidades concorrentes admite as seguintes possibilidades:....... Seu códigofonte é compilado gerando um arquivo “nome_do_arquivo........35 PROGRAMAÇÃO CONCORRENTE.................. também conhecida como execução paralela.............. Desenvolvida pela Sun Microsystems........................... Como já existia uma linguagem com este nome........6.33 4....7..SINCRONIZAÇÃO........43 VISÃO DO PROJETO.....43 REFERENCIAS BIBLIOGRÁFICAS...FLUXO DE EXECUÇÃO NORMAL E EXCEPCIONAL................ palms e mais precisamente nas aplicações web.... simples e portável a todas as plataformas e sistemas operacionais causou um grande impacto no mercado de informática...... Sua portabilidade é obtida pelo fato de ser uma LP compilada e interpretada....... porém com algumas características próprias... teve como seu criador..................... Com sua sintaxe parecida com a linguagem C/C++........................ James Gosling.......................................... existe mais de um fluxo de controle ativo.1..........class” que é chamado byte-code que no momento da execução é interpretado pela máquina virtual instalada no dispositivo.......... 1..EXCEÇÕES DEFINIDAS PELO USUÁRIO........................38 5.......................... foi dado o nome de Java (cidade de origem de um tipo de café importado)............34 4... não significa execução simultânea.......................1............. telefones celulares........4................................. 5 ........... HISTORICO E APLICATIBILIDADE DA LP JAVA...............................................

Fases da execução de um programa fonte em Java. } } Exemplo de um código Java <HTML> <HEAD> <TITLE> Java </TITLE> </HEAD> <BODY> <APPLET CODE=”nome.25). public class HelloWorldApplet extends java.2.drawString (“Hello World!”. 6 . MODELO DALINGUAGEM JAVA. A linguagem Java esta classificada no modelo de linguagem imperativo baseado na maquina de Von Neumann. import java.applet.Applet { public void paint (Graphics g) { g. onde expressa seqüências de comandos que transformam os dados de entrada em resultados de saída de acordo com o uso de como os computadores executam os programas em nível de máquina. pois é uma linguagem de programação orientada a objetos.5.class” WIDTH=300 HEIGHT=100> </APPLET> </BODY> </HTML> Exemplo de código Java embutido em html 1.awt.Graphics.

com ou sem multiprocessamento. que em geral demandam muito tempo do processador. Java permite múltiplas linhas de execução (threads) num mesmo programa e oferece primitivas para sincronizá-las.Maquina de Von Neumann 1. cálculos extensos. Cada um desses sistemas tem o seu tipo de multitarefa. de forma que a elaboração de aplicativos baseados em arquiteturas cliente-servidor é facilmente obtida. OS/2 e Unix. AVALIAÇÃO DA LINGUAGEM EM RELAÇÃO AOS CRITÉRIOS. FTP.3. A linguagem Java utiliza tanto o modelo de execução seqüencial quanto a concorrente.) são suportadas em Java. preemptiva ou não. Java tem o suporte a multitarefa embutido na linguagem: um programa Java pode possuir mais de uma linha de execução (thread). como o Windows. Java também oferece: • Processamento distribuído: Chamadas a funções de acesso remoto (sockets) e os protocolos Internet mais comuns (HTTP. podem ser escritos em uma 7 . o computador é capaz e executar diversas tarefas ao mesmo tempo. ou seja. Por exemplo. MODELOS DE EXECUÇÃO. Telnet. • Multithreading: A maior parte dos sistemas operacionais hoje no mercado dão suporte à multitarefa. etc.

• CONFIABILIDADE: 8 . • PORTABILIDADE: Possibilidade de ser executado em diferentes plataformas (Linux. e a parte de interface com o usuário. • ORTOGONALIDADE: Possibilidade de combinar entre si os componentes básicos da LP. Palavras reservadas tornam a linguagem mais legível à medida que seus nomes dão a ação a ser executada ou são usadas para separar entidades sintáticas. Programação concorrente em geral é uma tarefa difícil. a depender de como são escritos (em letras maiúsculas ou minúsculas).thread. 1. que depende mais dos periféricos de I/O que do processador.4. MECANISMOS QUE FACILITEM A PRODUÇÃO DEPROGRAMAS QUE ATENDAM AS SUAS ESPECIFICAÇÕES. • LEGIBILIDADE: Facilidade de ler e escrever programas. • EXPRESSIVIDADE: Representação clara e simples dos dados e procedimentos. Há uma desvantagem na LP Java devido os mesmos nomes serem diferentes. Principal característica das linguagens orientadas a objeto. Windows). pode ser executada em outra thread. mas Java fornece diversos recursos de sincronização de processos que tornam a programação mais simples.

O programador não consegue fazer uso de memória que não pertença a seu programa.ex. 1. A LP Java possui tipagem forte.741) “O tratamento de exceções de Java permite a um programa capturar todas as exceções. Permitindo dessa forma a verificação de erros de tipos. Sendo assim na LP Java os programas devem ser mais claros. p. Facilidade de detecção de erros haja vista que é uma linguagem fortemente tipada.5. FUNCIONAMENTO DO AMBIENTE DE GERAÇÃO DE CÓDIGO E EXECUÇÃO DE PROGRAMAS. Uma exceção é uma indicação de um problema na execução do programa. o mesmo programa deverá mostrar os mesmos resultados de saída. robustos e mais tolerantes a falha. O tratamento de exceções em Java foi projetado para cuidar de erros síncronos (tempo de compilação) e não em erros assíncronos (tempo de execução).: notepad no Windows ou edit do 9 . FUNCIONAMENTO DO AMBIENTE DE GERAÇÃO DE CÓDIGOS E EXECUÇÃO DE PROGRAMAS. A LP Java é baseada na implementação de linguagens com solução hibrida (parte compilada e parte interpretada). todas as exceções de um certo tipo ou todas as exceções de um tipo relacionado”. 1. ou seja. Durante o processo de execução é posto um textofonte criado num editor de texto simples (p. o compilador e o ambiente de execução se encarregam de fazer a verificação de tipos. A eliminação do uso de ponteiros em favor do uso de vetores e objetos.Ao receber os mesmos dados como parâmetro de entrada na sua execução.6. Sendo assim os erros de tipos são logo detectados em tempo de compilação. • TIPAGEM. • TRATAMENTO DE EXCEÇÃO. Na LP Java o numero e os tipos de erros podem aumentar de acordo com a extensibilidade do programa. Segundo Deitel (2000.

C. Apesar de ser uma linguagem portável. C++ e Dinamicamente tipadas (apenas valores têm tipos fixos) variáveis e parâmetros não possuem um tipo associado. O primeiro é a limitação em relação ao tamanho do nome do arquivo. Podem ser executados em tempo de compilação ou em tempo de execução. (Smalltalk. Pascal. de posse destas informações. Sistema de Tipos em Java Tipos de dados são conjuntos de valores que exibem um comportamento uniforme diante de operações associadas. parâmetros e um conjunto de regras para determinar a sua equivalência. variáveis.DOS) escrito na linguagem Java e salvo com a extensão java (nome_arquivo. Um sistema de tipos consiste basicamente de um mecanismo para definição de tipos de dados através de construções da linguagem de programação. Um tipo de dados determina a classe de valores que podem ser armazenados em uma variável. Segundo a LP Java foi projetada para sistemas de 32 bits um suporte limitado. Verificações de tipos (Type checks) são necessárias para assegurar que uma operação particular seja aplicada a operandos adequados. passados como parâmetro ou resultantes de uma expressão. O conhecimento dos possíveis valores de uma variável é essencial para o entendimento de um algoritmo. O tradutor. A informação de tipo em uma linguagem de programação é usada para prevenir ou detectar construções incorretas em um programa além de determinar os métodos de representação e manipulação de dados no computador. Há alguns problemas em utilizar o DOS como sistema operacional para a elaboração de aplicativos em Java. JavaScript) 10 . mas podem assumir valores de diferentes tipos em diferentes trechos do programa. atribuições e parâmetros.java). tais como constantes. Este código-fonte é submetido a um compilador que o converte num arquivo em linguagem de máquina chamado byte-code que será interpretado dando a característica de portabilidade. Saber quais são as operações permitidas possibilita a detecção de vários erros. As linguagens podem ser estaticamente tipadas (toda variável e parâmetro tem um tipo fixo escolhido pelo programador) como o Java. pode determinar o espaço necessário para as variáveis e como proceder para a implementação das operações e tratamento de exceções. a compatibilidade e a inferência de tipos para fins de verificação da validade do uso de tipos em expressões. não pode ser utilizada no DOS.

Java determina o tamanho de cada tipo primitivo. ao invés da criação da variável pelo uso de new.0f Tipo char short long double Valor Padrão ‘\\u0000’ (null) (short)0 0L 0. geralmente refletem a estrutura de hardware (mesmo que virtualmente implementados). a um conjunto finito de valores e a um conjunto pré-definido de operações especiais. os tipos primitivos assumem automaticamente valores.A linguagem Java oferece diversos tipos de dados que podem ser classificados basicamente em duas grandes categorias: tipos primitivos e tipos de referências (estruturados homogêneos e heterogêneos). isto é. Este tamanho não varia em razão de programas Java serem portáveis. Dessa forma. tornando o acesso muito mais eficiente. não definidos com base em outros tipos de dados. conforme tabela abaixo: Tipo Boolean byte int float Valor Padrão False (byte)0 0 0. Tipo boolean byte char short int long float double void Tamanho 8-bit 16-bit 16-bit 32-bit 64-bit 32-bit 64-bit — Mínimo — -128 Unicode 0 -215 -231 -263 IEEE754 IEEE754 — Máximo — +127 Unicode 216. associados a um nome. A razão para o tratamento especial é que esses tipos constituem um conjunto de dados simples. minimizando o esforço do desenvolvedor com a tarefa de conversão de dados em formatos apropriados para a portagem.1 +215—1 +231—1 +263—1 IEEE754 IEEE754 — Após terem sido declarados. As características dos tipos de dados primitivos independem da plataforma em que o programa deverá ser executado. TIPOS DE DADOS Tipos Primitivos São tipos atômicos. podendo ser mapeados diretamente. são inicializados. Esses tamanhos não se alteram de uma arquitetura de máquina para outra como acontece em muitas linguagens. Estas variáveis são alocadas diretamente na pilha. Isto é. indivisíveis. Para estes tipos Java recuou na abordagem tomada por C e C++.0d 11 . uma variável “automática” é criada e não uma referência. possibilita sua portabilidade entre diversos tipos de computadores.

tipos primitivos são tipos especiais construídos na linguagem. Uma variável booleana pode assumir apenas um entre dois valores: true ou false. double d1 = 123. Isso porque variáveis desses tipos podem conter um valor numérico inteiro dentro da faixa estabelecida para cada tipo individual.4f. porém em notação científica float f1 = 123. int. // Número 26. Algumas operações possíveis em Java como a<=b e x>y têm como resultado um valor booleano. é possível associar um literal a uma variável de um tipo primitvo: boolean result = true. octal ou hexadecimal.Tipo Boolean Este é o tipo de dado mais simples encontrado em Java. que pode ser armazenado para uso futuro em variáveis booleanas. Tipos inteiros (byte. Um literal é a representação em código fonte de um valor fixo. Literais Como observado a palavra-reservada new não é usada para inicializar uma variável de um tipo primitivo. em octal // Número 26. short e long constituem tipos de dados inteiros. Eles não são criados a partir de classes. F ou f (Literal de ponto flutuante de 32-bits) e D ou d (Literal de ponto flutuante de alta precisão 64-bits. double d2 = 1. int hexVal = 0x1a. são representados diretamente em seu código sem requerer computação alguma. byte b = 100. short s = 10000. int octVal = 032. Como mostrado abaixo.234e2. int decVal = 26. em decimal // Número 26. Literais do tipo char e String podem conter caracteres Unicode (UTF-16). Tipos de dados inteiros Os tipos de dados primitivos byte. Onde char é delimitado por aspas simples e String por aspas duplas 12 . char capitalC = 'C'. int e long) podem ser expressos usando sistemas de numeração decimal. short. int i = 100000. em hexadecimal Tipos de Dados de Ponto Flutuante Tipo de ponto flutuante (float e double) podem ser expressos usando E ou e (para notação científica). char. esse é o padrão e por convenção podes ser omitido).4. Conforme mencionado. //mesmo valor que d1. Estas operações são chamadas operações lógicas.

e se tentar usar uma referência que ainda é null. Usar vetores em C e C++ é arriscado porque eles são somente blocos de memória. 600. estes típicos erros de vetores são prevenidos em Java. Se um programa acessa além do bloco de memória do vetor ou usa a memória antes de sua inicialização (erros comuns de programação). o problema será reportado em tempo de execução. //Vetor umArray = new int[10]. 800. 13 . 1000}. A checagem de limite veio com o preço de ter um pequeno montante de memória a mais em cada vetor apenas para verificar o índice em tempo de execução. o compilador garante inicialização porque ele zera a memória para este vetor. 200. Abaixo vemos uma representação de um vetor. //Matriz bidimensional String[][] names = {{"Mr. int[][] m1. Um vetor Java é garantido para ser inicializado e não pode ser acessado além de seus limites. Pode-se também criar um vetor de primitivos. está criando um vetor de referências. haverá resultados imprevisíveis. Para definir um vetor. mas a compreensão é que a segurança e a produtividade ampliadas cobrem o custo. "}. Então. "Mrs. ". Novamente. int[] a1. Quando você cria um vetor de objetos.TIPOS ESTRUTURADOS Vetores e Matrizes Virtualmente todas as linguagens de programação suportam vetores. você na realidade. reconhece que a referência em questão não está apontando para um objeto. "Ms. de inteiro. 700. 300. vetor de inteiros 400. ". e cada uma destas referências é automaticamente inicializada com um valor especial com sua própria palavra chave: null. simplesmente segue seu nome de tipo com colchetes fechados vazios: A obj_a = new A(). assim muitos dos problemas que afligem programadores em C e C++ não são repetidos em Java. 500. Um vetor é simplesmente uma seqüência de outros objetos ou primitivos que são todos do mesmo tipo e empacotados juntos sob um nome identificador. Quando Java encontra null. 900. pois é preciso atribuir um objeto para cada referência antes de usá-la. Um dos principais objetivos de Java é a segurança. // cria um int[] outroArray = {100. Vetores são definidos e usados com o operador indexado colchetes fechados [].

O Java utiliza a compatibilidade de objetos por estrutura e tipos primitivos por nome.print(planet.*. Todavia. introduzida pela palavra chave enum e seguida por um nome de tipo. porém altamente restritiva. Os valores dessas constantes começam em 0. É mais difícil de implementar porém garante maior flexibilidade.JUPITER.out. reservar de espaço de memória e definir d tamanho e armazenagem de elementos.").variáveis são compatíveis se estiverem na mesma declaração ou em declarações que usem o mesmo nome de tipo.TERRA.util.ordinal() + "\n").MARTE. é um conjunto de constantes representadas por identificadores.variáveis são compatíveis se os seus tipos tiverem estruturas idênticas. Enumerações Uma enumeração é um tipo definido pelo usuário.{"Smith". public class Teste { public enum Planet{MERCURIO. 14 . a menos que seja especificado de outra forma e são incrementados por 1.out. qualquer uma delas pode ter seu valor atribuído à outra.values()){ System. O trecho de código abaixo mostra o uso de uma enumeração. VENUS. System. além dos operadores e tipos envolvidos.lang. } } COMPATIBILIDADE DE TIPOS Quando duas variáveis são de tipos compatíveis. import java. public Teste(){ for(Planet planet:Planet.name() + " .N ETUNO.URANO. É fácil de ser implementada. "Jones"}}. • Compatibilidade de Estrutura . Existem dois métodos diferentes de compatibilidade de tipos: • Compatibilidade de Nome .print(planet. } } public static void main(String args[]){ new Teste(). uma enumeração é definida na classe Enum que faz parte do pacote java. Uma enumeração.SATURNO. PLUTAO}. A utilização de vetores e matrizes em Java envolve três etapas: declarar do vetor ou matriz. A idéia de compatibilidade de tipos está relacionada a questões de verificação de tipos Inferência de tipo Capacidade que a linguagem tem para determinar os tipos das variáveis tendo em consideração o contexto em que se encontram.

decremento Multiplicação. subtração Translação (bit a bit) à esquerda.-. somos levados naturalmente a multiplicar primeiro b com c e em seguida o somar o produto com a. No Java as regras de precedência estão descritas na tabela abaixo: Operador . O primeiro se refere a conversão implícita na qual.Expressões são combinações ordenadas de valores. Precedência de Operadores Há situações em que é necessário juntar operadores diferentes numa mesma expressão.>. direita sinalizada. menor ou igual. parâmetros. negativo. escrevendo a+b*c. A precedência é então um conjunto de regras que permitem determinar quais são os operandos de um dado operador. os dados são convertidos automaticamente. diferente Operador lógico e bit a bit Ou exclusivo (xor) bit a bit Operador lógico ou bit a bit Operador lógico e condicional Operador lógico ou condicional Condicional: if-then-else compacto Atribuição 15 .(tipo) +.-* / % + << >> <. indexação. variáveis.!= & ^ | && || ?: = Conversão de Tipos Ao trabalhar com expressões.. maior Igualdade: igual. salvo quando todos os operando são do mesmo tipo.~.>= ==. Por exemplo. Nesse caso a associatividade não se aplica mais trivialmente. Torna-se necessário determinar quais são os operandos de um operador e qual sua ordem de avaliação. maior ou igual. Com base nas regras de precedência descrita a seguir o Java pode. praticamente sem a preocupação do programador (baseadas nas regras de conversão da linguagem). incremento.<=. comparar valores. permitindo realizar cálculos aritméticos. negação (inversão bit a bit). é inevitável ter que considerar conversões entre um tipo de dado e outro. operadores. e direita não sinalizada (o bit de sinal será 0) Operador relacional: menor. conversão de tipo Operador unário: positivo. Uma expressão em Java pode produzir três resultados: • Um valor.[]. determinar o tipo resultante. • Uma variável (uma referência a uma variável).++. divisão e módulo (inteiros) Adição. não (lógico).!. na maioria dos casos. parênteses e chamadas de métodos. As regras de conversão implícita empregadas pela linguagem Java são as seguintes: Descrição Máxima precedência: separador. Isto porque a multiplicação tem precedência sobre a adição. O segundo tipo é a conversão explícita (efetuadas pelo programador) Conversão Implícita As regras de conversão resultam da capacidade de inferência da linguagem e de sua tipificação. • Nada (a expressão é void). concatenarem strings. realizar operações lógicas e manipular objetos. Há basicamente dois tipos de conversões de dados.().

Por exemplo: float eventos = 25. (tipo) expressão O cast de tipo tem a maior precedência possível. x = (int)(eventos / dias). Do contrário. RTTI ou Run-Time Type Identification (Identificação de Tipos em Tempo de Execução) garante que as conversões sejam sempre seguras.2. e o resultado será um float. e os demais tipos não são afetados. public class Teste { public static void main(String[] args) { Animal a = new Cachorro(). Isto pode ser feito por meio de um operador unário de conversão. é importante podermos controlar precisamente a ocorrência de uma conversão de tipo. fora da hierarquia (erro de compilação) nem dentro da hierarquia (erro de execução).7. se um dos operadores for double. Nesse caso. Nesses casos. e não há necessidade de parênteses extra. Algumas vezes. o outro será convertido para double antes de realizar a operação e o resultado será um double. as conversões implícitas não são suficientes para garantir um resultado esperado em uma expressão. // Erro de compilação: 16 . tem sintaxe herdada do C. as regras são um pouco mais complicadas. a menos que o resultado da operação seja grande demais para caber num int. o tipo das variáveis é definido uma vez na declaração e não pode ser alterado. Conversão Explícita Conversão explicita é realizada através do uso de type casting ou métodos específicos disponibilizados wappers de tipos primitivos. O valor da expressão é forçado a ser de um tipo particular. // Erro de execução (ClassCastException): Gato g = (Gato)a.convertem um tipo byte e short são convertidos para um int. ambos os operando são convertidos para float. Determinação Dinâmica de Tipos O Java disponibiliza um mecanismo que permite verificar e determinar o tipo de um objeto em tempo de execução chamado RTTI. não importando a regra de conversão de tipos. ambos os operandos são convertidos para um int e o resultado será também um int. se um dos operandos for long. Não permite que um objeto seja convertido para uma classe inválida. // Sem erro nenhum: Cachorro c = (Cachorro)a. descrito com mais detalhes a seguir. float dias = 7. Caso contrário. o outro será convertido para um long antes de realizar a operação. Para os operadores binários.• • Os operadores unários ++ e -. O operador de cast. o Para operações envolvendo apenas inteiros. a qual resultará num long. mostrado abaixo. porém. portanto podemos fazer o cast de a ou de b para ser do tipo float. O cast não modifica o tipo da variável. o resultado será convertido para um long. Para operações envolvendo números de ponto flutuante. O código a seguir demonstra um erro de execução.

isto é. new Gato(). Possibilitam o encapsulamento. pois a representação do tipo deve ser acessada somente no ambiente encapsulado. busca e etc. São exemplos de tipos abstratos de dados: • Uma árvore binária com as operações usuais de inserção. } } } TIPO ABSTRATO DE DADOS (TAD) É a representação ou definição do tipo e as operações sobre objetos em uma única unidade sintática.miar().. Tem como principais vantagens: • O fato do código e estrutura de dados de uma abstração estar armazenados num mesmo lugar cria um programa bem estruturado e legível que pode ser facilmente modificado. for (int i = 0.String s = (String)a.latir(). Completando este conceito amplo podemos dizer que uma classe implementa um tipo abstrato de dados. Proporciona uma abstração sobre uma estrutura de dados em termos de uma interface bem definida. } } O mecanismo RTTI permite que seja determinado o tipo de um objeto através operador instanceof. else if (vet[i] instanceof Gato) Gato)vet[i]). • O aspecto do ocultamento da informação e encapsulamento proporcionam um nível de proteção contra acessos inesperados à estrutura de dados. 17 . definição isolada de outras unidades do programa. new Cachorro()}. que retorna verdadeiro se a instância for da classe (direta ou indiretamente) em questão.length. O encapsulamento promove uma organização lógica de dados e respectivas operações. o que mantém a integridade do objeto. remoção. ele separa utilização e implementação. outras unidades do programa podem ter permissão para criar variáveis do tipo definido. i++) { if (vet[i] instanceof Cachorro) ((Cachorro)vet[i]). new Gato(). Podem combinar abstrações de dados e de procedimento. i < vet. sua sintaxe é mostrada abaixo: <objeto> instanceof <Classe> O exemplo de código abaixo demonstra o uso do operador instanceof: public class Teste { public static void main(String[] args) { Animal[] vet = new Animal[] {new Cachorro(). invisibilidade e proteção. A representação dos objetos não é visível pelas unidades do programa que usam o tipo e as operações sobre os objetos são aquelas oferecidas na definição.

public class Ponto { private int x.x = _x. } public void moverPara(int dx. bem como as operações para converter para radianos. • Código Equivalente: import java. Segundos).*. entre outras. int dy) { this. Exemplo: Onde: • x e y são variáveis privadas. } public int getValorY() { return this. • Clone é um método que retorna a própria instância. Os Sets/Gets são métodos que acessam as variáveis privadas. } } Atributos 18 . Também com as operações relacionadas.x += dx. acessadas apenas internamente. Embora o conceito de classe seja independente do Java. } public void setValorX(int _x) { this.y.y = _y.• • Uma representação para números racionais (numerador. enquanto objeto é uma instância de uma classe. denominador) que possua as operações aritméticas básicas e outras de conversão de tipos.y += dy. Minutos. private int y. Uma representação para ângulos na forma (Graus. Uma das principais estruturas que fornece as capacidades mencionadas acima se chama classe. é importante ressaltar que classe é um modelo ou especificação que define um tipo de objeto. this.util. public Ponto() { } public Ponto clone() { return this. } public int getValorX() { return this.x. • <<Construtor>> estereótipo que indica que Clone é um construtor da classe. } public void setValorY(int _y) { this.

Um tipo compatível é aquele válido para o operador ou com permissão. deve ser criado um objeto. os serviços oferecidos. idênticos independente da arquitetura de hardware utilizada. Um exemplo é a criação de uma classe Funcionario. A classe Ponto pode. Na atual implementação da SUN. para ser convertido pelo código gerado pelo compilador para um tipo válido. a sua interface. Existem outros tipos de modificadores que se aplicam às classes. área de método. área de frames. Métodos Além de atributos. resultante de expressões. Representação de Objetos A JVM não requer qualquer estrutura particular interna para objetos. Herança A herança é um mecanismo através do qual novas e mais especializadas classes podem ser definidas em termos de classes pré-existentes. Essas variáveis são visíveis apenas dentro da classe. nas regras da linguagem. refletindo a própria estrutura lógica do hardware.violação de tipo por atribuição.violação de tipo por leitura.Como dito. A classe oferece um método especial que é executado no momento em que ela é instanciada. isto é. um heap. A verificação de tipos é atividade de assegurar que os operandos de um operador sejam de tipos compatíveis. com valor proveniente do meio externo. um pool de constantes e etc. uma referência para a instância da classe é um ponteiro que aponta para um par de outros 19 . Violação de Tipos Um dos principais objetivos da utilização de sistemas de tipos em linguagens de programação é permitir a detecção de erros (de tipos). Um erro de tipo é a aplicação de um operador a um operando de tipo impróprio. ou de forma dinâmica. como uma subclasse de Pessoa. isto é. quando a variável tem sua representação interna associada a um descritor de tipo como no caso do Java. A detecção de erros pode ser feita de forma estática. Dinâmica . atributos e métodos. uma classe deve definir os métodos que irá disponibilizar. ela o faz através de das variáveis privadas x e y. Representação de tipos A representação interna pode ser direta. A classe Ponto precisa armazenar as coordenadas do ponto sendo representado de alguma forma. caso seja possível à detecção somente durante a execução de programa. por exemplo. prover um método para mover o ponto de um dado deslocamento. A máquina virtual provê uma área de dados. este método é chamado de Construtor. tais formas são descritas abaixo: • • Estática . A essa conversão chama-se coerção. Instanciação Uma classe para ser usada deve instanciada. classes definem dados que suas instâncias conterão. ou indireta. somente poderá ser detectada pelo ambiente de execução.

VINCULAÇÃO Um objeto pode ser identificado por seis informações distintas. 3. Na LP Java nem todos os caracteres de conexão são permitidos. AMARRAÇÃO. a distinção entre maiúsculas e minúsculas e o uso de palavras reservadas. AMBIENTE DE NOMES. nome. São elas: tipo. |) permitidos pela linguagem. Na implementação de projetos para nomes devemos nos preocupar com o tamanho máximo para cada nome.sun. ASSOCIAÇÃO: (BINDING). um outro para o objeto de classe que representa o seu tipo e um outro ainda para a memória alocada no heap para os dados do objeto. Verificação dos caracteres de conexão (@. Mesmas palavras podem ser consideradas diferentes dependendo de serem escrita em maiúsculas ou minúsculas. Para maiores http://java. De posse dessas informações é possível controlar e manipular os objetos.html detalhes: 2. Palavras especiais em algumas linguagens podem ser chamadas de palavras reservadas em outras pode ser chamada de palavras chave. tempo de vida. endereço de memória. _.com/docs/books/jvms/first_edition/html/VMSpecTOC.1.doc. $. escopo. a permissão para o uso de caracteres de conexão. O conceito de amarração ou vinculação (binding) se refere à associação dos valores dados a cada uma dessas 20 . %. Na LP Java não existe um tamanho máximo para um nome de um objeto. Em Java as palavras reservadas são independentes do contexto e não podem ser usadas como nomes. valor. #.ponteiros: uma para uma tabela contendo os métodos do objeto.

possíveis valores para o tipo float. • Implementação da Linguagem: 21 . o Memória indica a posição de memória onde os nomes associados ao objeto se encontram. A vinculação pode ocorrer nos seguintes tempos: • Projeto da Linguagem: i. ii. o Espaço de tipos indica o valor e o tipo do objeto. possíveis tipos para raio. public float b. Por exemplo: uma variável e seus atributos.informações pertencentes ao objeto ou variável. public float a. O momento em que a vinculação ocorre é chamado tempo de vinculação. Exemplo de associação de informações de um objeto: public class Circulo{ public float raio = 1. o Tabela de identificadores indica o nome associado ao objeto. } Classe circulo e seus atributos. ou uma operação com seu símbolo.

Em tempo de execução os processos de vinculação podem ser: • • • Automáticos – objetos criados e destruídos nos blocos de código em execução. significado do sinal de atribuição. • Tempo de execução: i. tipo de raio. Amarração dinâmica é determinada no tempo de execução de um código-objeto para associação dos objetos e suas características.println ( “O valor de a é: ” + 2 * b + “ . objetos e métodos) independente de sua execução. Na amarração dinâmica é possível verificar o estado da CPU. 4 int b = 10.i. 5 System. São alocados numa área de memória chamada heap. • Tempo de compilação: i. São alocados na área de memória chamada stack. endereço e nome). representação interna da memória para o valor 1. As amarrações classificadas em função do relacionamento entre os objetos são relacionadas abaixo: 1 class Aritmetica { 2 public static void main(Strings args[] ){ 3 int a. VINCULAÇÃO ESTÁTICA E DINÂMICA. é possível identificar detalhes do ambiente de programação (classes. A amarração estática é determinada no tempo de compilação de um código-fonte para associação dos objetos e suas características. 6 } 22 7} . Dinâmicos – variáveis são alocadas e desalocadas dinamicamente. valor. As amarrações podem ser classificadas em função do instante de execução (amarração estática ou dinâmica) ou em função do relacionamento entre os objetos (amarração de tipo.out. o gerenciamento de memória e os processos em execução ou os candidatos à execução. ii.2. 3. São armazenadas na heap. ii. o de b é: “ + b ). Estáticos – variáveis globais que são destruídas no final do programa. Ou seja. associação de raio a um endereço de memória. valor de raio – operação de atribuição do numero um à variável. dados.

Amarração estática de objetos • Linha 3 amarração de tipo. • Linha 4 amarração de tipo e valor. 23 .

permitindo a criação de novos objetos. Nas linguagens de programação onde se permite alocação dinâmica de memória. Sendo assim os objetos que não estão sendo mais utilizados são identificados pelo procedimento que libera o espaço utilizado por estes objetos. Caso o programador não desaloque a área de memória previamente alocada e que não esta mais utilizada há uma geração de um problema chamado de “vazamento de memória”.3. objeto ou variável. Alocação de memória é marcar ou disponibilizar uma área de memória para guardar um determinado dado. DURAÇÃO E GERENCIAMENTO DE MEMÓRIA.3. 24 . Antes de explicitar como funciona o gerenciamento de memória daremos uma breve definição do que vem a ser alocação e desalocação de memória. os desenvolvedores da LP Java criaram um procedimento de coleta automática de lixo a maquina virtual. que não permite que novos objetos sejam criados mesmo com espaço de memória disponível. o programador fica responsável pela liberação da memória obtida com a alocação e que não esta mais sendo utilizada. Desalocação de memória é quando a área de memória alocada é liberada para que um novo objeto possa usá-la. Pensando em problemas gerados no uso de alocação e liberação de memória dinâmica.

public Robo (int ax.As variáveis estáticas são criadas no inicio do bloco lógico. ou seja. Para criação de variáveis dinâmicas podemos utilizar o operador NEW. Os métodos e as variáveis de uma classe têm escopo de classe. onde há uma alocação de posição de memória para as mesmas. As variáveis declaradas dentro de um método são chamadas de locais e possuem duração automática. Circulo = umcirc. class Robo{ public int x. public int y. 3. ALCANCE E VISIBILIDADE. 25 . DURAÇÃO. e as variáveis declaradas dentro de um bloco têm escopo de bloco.4. } } Criação de variáveis estáticas com o modificador static. umcirc = new Circulo( ). Esse tempo é chamado de tempo de vida de uma variável. Como foi visto anteriormente as variáveis podem ser usadas ao longo de todo o programa ou por partes do programa. public static int cont. e são destruídas no termino do bloco lógico. onde as posições de memória antes ocupadas são liberadas. são criadas no inicio do bloco lógico pertencente ao método e destruídas no final do bloco lógico. As variáveis estáticas dentro da classe que as define e tem a durabilidade ate o final da execução do programa. Exemplo da criação de uma variável dinâmica utilizando o operador NEW. cont ++. A faixa de instrução onde a variável pode ser visível chama-se escopo de variável. Essa posição de memória é ocupada até o termino da execução do programa. int ay){ x = ax. A duração de uma variável é o tempo durante o qual essa variável existe na memória. Quando um objeto ou uma variável dinâmica é criado o sistema aloca uma posição de memória para esse objeto ou variável. y = ay.

3.. eles têm conceitos totalmente diferentes. } public void useLocal( ){ . Por exemplo: public void start( ){ int x = 5. tem-se que levantar (jogar) uma exceção e tratar uma exceção.... mas em Java não. Porém o tempo de vida de “x” se estende durante toda a execução do método useLocal( ). Se ocorrer 26 . Em algumas linguagens que implementam tratamento é perfeitamente possível programar sem usar esse recurso. 4. .1... TRATAMENTO DE EXCEÇÕES. . O modelo de tratamento de exceções adotado por Java é similar ao adotado por C+ +. } O escopo da variável x está contido pelo metodo start( ). então o método que está sendo executado é imediatamente terminado e o controle passa para o método que o chamou. useLocal ( ). Uma exceção será levantada quando for verificada uma condição anormal de funcionamento do programa. Visa preencher as lacunas existentes pela insuficiência da programação orientada a objeto para representar a complexidade do objeto na vida real. Um dos motivos de o programador Java ter que saber tratamento de exceções é que os métodos de classes definidas na linguagem podem gerar exceções e na maioria das vezes o compilador obriga a escrita de tratadores (blocos try{} catch{}) para chamadas destes métodos. onde pode ocorrer um tratador da exceção ou não.Apesar de escopo e tempo de vida parecer estar relacionados. Para estruturar o código dessa forma. Java é uma linguagem que faz forte uso do conceito de tratamento de exceções. SISTEMA DE TRATAMENTO DE EXCEÇÕES.

Lançar ou jogar uma exceção é suspender a execução do método atual e passar um objeto para o bloco catch mais próximo na cadeia de chamadas de métodos atual. podendo culminar no término do programa se toda a cadeia de chamada de métodos for desfeita até chegar em main sem que se ache um tratador para esta exceção. justamente por essas terminações de métodos. IllegalArgumentExceptione=new IllegalArgumentException("Erro!"). 3. erro interno do JVM Fogem do controle do programador e não podem ser contornados. //ou throw new nomedaclassedoobjeto(argumentos do construtor) Throw é como um break para métodos. divisão por zero Devem ser corrigidos pelo programador 2. throw e. Se não ocorrer um tratador outras chamadas de métodos são “desfeitas”.um tratador. rede fora do ar. etc. Erros devido a condições do ambiente de execução Ex: arquivo não encontrado. precisa-se criar uma new e depois lançar uma throw. As exceções são erros em tempo de execução através de objetos criados a partir de classes especiais que são "lançados" quando ocorrem condições excepcionais. o modelo adotado por Java recebe o nome de: “termination model”. encerradas. Erros graves onde não adianta tentar recuperação Ex: falta de memória. Erros de lógica de programação Ex: limites do vetor ultrapassados. podendo ser contornados em tempo de execução. na maioria dos casos a exceção pára de se propagar ali mesmo. Existem vários modelos de tratamento de exceções. Para isso. Podem ocorrer três tipos de erros em tempo de execução: 1. A sintaxe abaixo é mais usual: 27 . Isto é feito através da declaração: throw nomedoobjeto. Fogem do controle do programador. Uma exceção é um tipo de objeto que sinaliza que uma condição excepcional ocorreu. // exceção foi lançada! A referência é desnecessária.

3 //qualquer código escrito aqui (depois de a[4]=10. Uma declaração throw é obrigatória em métodos e construtores que deixam de capturar uma ou mais exceções que ocorrem em seu interior: public void m() throws Excecao1. é possível escolher que código de tratamento usar com cada tipo de exceção gerada. As exceções geradas pela linguagem pertencem a uma hierarquia cujo topo é a classe Throwable.. Dispondo mais de um tratador (bloco catch) em seqüência. Assim sendo.2. os índices validos são //quatro:0.) //nunca será executado } catch(Exception e) { //refaz a pergunta do índice a alterar ao usuário //e descobre que ele queria alterar o valor no índice 3. Ex. try { a[4]=10. Como exceções são objetos. as condições anormais de seu programa contendo as mensagens de erro e as possíveis soluções. Acesso a índice inválido do vetor sem corromper o sistema: //Classe principal. HIERARQUIA DE EXCEÇÕES. o programador só precisará tratar as da hierarquia de Exception. onde os primeiros só tratam as classes exceções mais baixas da hierarquia.} public Circulo() throws ExcecaoDeLimite {. Por sorte.} throw declara que o método pode provocar exceções do tipo declarado (ou de qualquer subtipo). Excecao2 {. em termos de informações.1.2.. 4. Os tratadores de exceção são escolhidos comparando a classe da exceção jogada e a classe de exceções que o tratador diz tratar. o tratador: try { /*algo que possa gerar uma exceção*/ } catch (Exception erro) { /* ações de tratamento do erro com possível nova tentativa de execução dos métodos chamados*/ } Seria capaz de tratar todas as exceções que estejam abaixo de Exception (na hierarquia) geradas em try { }.java class Principal { public static void main(String args[]) { int a[]=new int[4].throw new IllegalArgumentException("Erro!"). das exceções levantadas pela linguagem. //linha acima gera exceção. 28 . pode-se definir hierarquias de classes de exceções.. Arquivo Principal. imediatamente estendida por Error e Exception. que mapeiem.. escrevendo //12 a[3]=12.

metodoMau().. É para isso que existe em Java o bloco try{ } catch{}finally{}.. } finally tem sido usado para fechar arquivos.println(a[3]). Se em algum lugar ela for capturada. ela irá causar o término da aplicação. por exemplo.. ela será propagada para o método que chamar esse método e assim por diante. FLUXO DE EXCEPCIONAL.3..:fechar um arquivo) antes do método ser terminado. } //instruções que sempre serão executadas } public void metodoBom() { try { . } } O fato do código imediatamente após o ponto onde foi gerada a exceção não ser executado poderia ser um problema. instruções . Se ninguém capturar a exceção. Exemplo clássico de uso do bloco try{} catch{} finally {}: try { //abre um arquivo //gera uma exceção com arquivos }catch (ExcecaoArquivo e){ //tenta recuperar arquivo e informações perdidas finally { arquivo. Se o método onde ela ocorrer não a capturar.. 4.close().} System. Captura e declaração de exceções: public class RelatorioFinanceiro { public void metodoMau() throws ExcecaoContabil { if ( ! dadosCorretos) { throw new ExcecaoContabil("Dados Incorretos"). que não existe em C++. precisar de uma chance de liberar recursos do sistema (ex. A cláusula finally{ } é opcional... EXECUÇÃO NORMAL E Uma exceção lançada interrompe o fluxo normal do programa. 29 .out. o controle pode ser recuperado.. seu código será executado ocorra ou não uma exceção no bloco try{} . como. // instruções serão executadas se exceção não ocorrer .. parar threads e descartar janelas.O fluxo do programa segue a exceção. instruções .

out. 4.lang. campos de dados e construtores como em qualquer classe. //instruções serão executadas se exceção não ocorrer ou // ou se ocorrer e for capturada } } O bloco try "tenta" executar um bloco de código que pode causar exceção. Pode-se. instruções . se entre os blocos catch houver exceção da mesma hierarquia de classe. Uma observação importante é que um bloco catch também pode gerar exceções. Porém.println("Erro: " + ex. Os blocos cath recebe. assim. Ocorrendo uma exceção no try.. uma exceção do tipo da específica jamais será capturado. também. havendo uma exceção que não se conseguiu tratar. O compilador detecta esta situação e não compila o código. } .Exception: class NovaExcecao extends Exception { } Não precisa de mais nada.} catch (ExcecaoContabil ex) { System. Para criar uma classe que represente sua exceção. pode-se fazer um throw dela mesma ou mudar a classe da exceção e continuar propagando (throw de outra exceção). sendo seguido por um ou mais blocos catch(TipoDeExcecao ref) e seguido ou não de um bloco finally.getMessage()). ou fazer a reparação do erro e jogar uma exceção para que seja completada por outros métodos. tipo de exceção como argumento. O mais importante é herdar de Exception e fornecer uma identificação diferente.. as classes mais específicas devem aparecer primeiro. caso contrário. O bloco catch usa o nome da classe para identificar exceções.4. O bloco finally contém instruções que devem ser executadas independentemente da ocorrência ou não de exceções. EXCEÇÕES DEFINIDAS PELO USUÁRIO. basta estender java.. class Principal { 30 .. ela irá descer pelos catch até encontrar um que declare capturar exceção de uma classe ou superclasse de exceção. Apenas um bloco catch é capturado. acrescentar métodos.

System. Exception(String message. SISTEMA DE TRATAMENTO DE EXCEÇÕES. }cath(DivisaoPorZero minhaexcecao){ System. } } } Os principais métodos construtores de Exception são: Exception(). Exception(String message). existem exceções que não são verificadas em tempo de compilação. Java é uma linguagem que faz forte uso do conceito de tratamento de exceções.print("Esta e' a fracao a: "). b=new Fracao(2. // retorna exceção que causou esta exceção String toString(). // retorna mensagem passada pelo construtor Trowable getCause().out. 4.println("Nao posso dividir por zero"). 4.print("Esta e' a fracao b: "). mas. O modelo de tratamento de exceções adotado por Java é similar ao adotado por C+ +. Subclasses de RuntimeException representam erros de lógica de programação que devem ser corrigidos. b.c. // retorna nome da exceção e mensagem void printStackTrace(). As subclasses de Error não devem ser capturadas (são situações graves em que a recuperação é impossível ou indesejável). a=new Fracao(5. // imprime detalhes sobre exceção As Exception são exceções verificadas em tempo de compilação. Trowable cause).mostra(). presentes nas classes Runtime Exception e Error da API.0). TRATAMENTO DE EXCEÇÕES. try { c=a. Em algumas 31 .public static void main(String args[]){ Fracao a.out. Podem ser capturados. preferencialmente. Visa preencher as lacunas existentes pela insuficiência da programação orientada a objeto para representar a complexidade do objeto na vida real. Os principais métodos de Exception são: String getMessage().mostra(). Porém. c. System.out. O compilador exige que sejam capturadas ou declaradas pelo método que potencialmente as provoca.mostra().5.3). a.divisao(b).b. devem ser corrigidos.

onde pode ocorrer um tratador da exceção ou não. Isto é feito através da declaração: throw nomedoobjeto. Erros de lógica de programação Ex: limites do vetor ultrapassados. Lançar ou jogar uma exceção é suspender a execução do método atual e passar um objeto para o bloco catch mais próximo na cadeia de chamadas de métodos atual. podendo ser contornados em tempo de execução. tem-se que levantar (jogar) uma exceção e tratar uma exceção. Erros graves onde não adianta tentar recuperação 32 . o modelo adotado por Java recebe o nome de: “termination model”. Existem vários modelos de tratamento de exceções. na maioria dos casos a exceção pára de se propagar ali mesmo. Uma exceção será levantada quando for verificada uma condição anormal de funcionamento do programa. justamente por essas terminações de métodos. Erros devido a condições do ambiente de execução Ex: arquivo não encontrado. encerradas. etc. Se não ocorrer um tratador outras chamadas de métodos são “desfeitas”. rede fora do ar. mas em Java não. 3. Podem ocorrem três tipos de erros em tempo de execução: 1. As exceções são erros em tempo de execução tratadas através de objetos criados a partir de classes especiais que são "lançados" quando ocorrem condições excepcionais. Fogem do controle do programador. Se ocorrer um tratador. Um dos motivos de o programador Java ter que saber tratamento de exceções é que os métodos de classes definidas na linguagem podem gerar exceções e na maioria das vezes o compilador obriga a escrita de tratadores (blocos try{} catch{}) para chamadas destes métodos. //ou throw new nomedaclassedoobjeto(argumentos do construtor) Throw é como um break para métodos. podendo culminar no término do programa se toda a cadeia de chamada de métodos for desfeita até chegar em main sem que se ache um tratador para esta exceção.linguagens que implementam tratamento é perfeitamente possível programar sem usar esse recurso. então o método que está sendo executado é imediatamente terminado e o controle passa para o método que o chamou. Para estruturar o código dessa forma. divisão por zero Devem ser corrigidos pelo programador 2.

// exceção foi lançada! A referência é desnecessária.6. Ex. Arquivo Principal. Assim sendo. Dispondo mais de um tratador (bloco catch) em seqüência. é possível escolher que código de tratamento usar com cada tipo de exceção gerada. erro interno do JVM Fogem do controle do programador e não podem ser contornados. imediatamente estendida por Error e Exception. A sintaxe abaixo é mais usual: throw new IllegalArgumentException("Erro!").. o programador só precisará tratar as da hierarquia de Exception.java 33 .} throw declara que o método pode provocar exceções do tipo declarado (ou de qualquer subtipo). precisa-se criar uma new e depois lançar uma throw.Ex: falta de memória.} public Circulo() throws ExcecaoDeLimite {.. Por sorte... em termos de informações. Uma exceção é um tipo de objeto que sinaliza que uma condição excepcional ocorreu. Como exceções são objetos. Para isso. que mapeiem. onde os primeiros só tratam as classes exceções mais baixas da hierarquia. Os tratadores de exceção são escolhidos comparando a classe da exceção jogada e a classe de exceções que o tratador diz tratar. HIERARQUIA DE EXCEÇÕES. o tratador: try { /*algo que possa gerar uma exceção*/ } catch (Exception erro) { /* ações de tratamento do erro com possível nova tentativa de execução dos métodos chamados*/ } Seria capaz de tratar todas as exceções que estejam abaixo de Exception (na hierarquia) geradas em try { }. As exceções geradas pela linguagem pertencem a uma hierarquia cujo topo é a classe Throwable. 4. das exceções levantadas pela linguagem. IllegalArgumentException=new IllegalArgumentException("Erro!"). as condições anormais de seu programa contendo as mensagens de erro e as possíveis soluções. Acesso a índice inválido do vetor sem corromper o sistema: //Classe principal. throw e. Uma declaração throw é obrigatória em métodos e construtores que deixam de capturar uma ou mais exceções que ocorrem em seu interior: public void m() throws Excecao1. pode-se definir hierarquias de classes de exceções. Excecao2 {.

1.O fluxo do programa segue a exceção. É para isso que existe em Java o bloco try{ } catch{}finally{}.2. ela será propagada para o método que chamar esse método e assim por diante.close().println(a[3]). FLUXO DE EXCEPCIONAL. precisar de uma chance de liberar recursos do sistema (ex.) //nunca será executado } catch(Exception e) { //refaz a pergunta do índice a alterar ao usuário //e descobre que ele queria alterar o valor no índice 3. Se o método onde ela ocorrer não a capturar.:fechar um arquivo) antes do método ser terminado. try { a[4]=10. Se ninguém capturar a 34 . //linha acima gera exceção. } } O fato do código imediatamente após o ponto onde foi gerada a exceção não ser executado poderia ser um problema.out. seu código será executado ocorra ou não uma exceção no bloco try{} . EXECUÇÃO NORMAL E Uma exceção lançada interrompe o fluxo normal do programa. escrevendo 12 a[3]=12. A cláusula finally{ } é opcional. por exemplo. Exemplo clássico de uso do bloco try{} catch{} finally {}: try { //abre um arquivo //gera uma exceção com arquivos }catch (ExcecaoArquivo e){ //tenta recuperar arquivo e informações perdidas finally { arquivo. os índices validos são quatro:0. que não existe em C++. como. parar threads e descartar janelas.7. 4.. } System. } finally tem sido usado para fechar arquivos.3 //qualquer código escrito aqui (depois de a[4]=10.class Principal { public static void main(String args[]) { int a[]=new int[4].

instruções .out. EXCEÇÕES DEFINIDAS PELO USUÁRIO.. metodoMau(). instruções . O bloco finally contém instruções que devem ser executadas independentemente da ocorrência ou não de exceções. //instruções serão executadas se exceção não ocorrer ou // ou se ocorrer e for capturada } } O bloco try "tenta" executar um bloco de código que pode causar exceção. basta estender java.. também. } //instruções que sempre serão executadas } public void metodoBom() { try { . Captura e declaração de exceções: public class RelatorioFinanceiro { public void metodoMau() throws ExcecaoContabil { if ( ! dadosCorretos) { throw new ExcecaoContabil("Dados Incorretos"). O bloco catch usa o nome da classe para identificar exceções.getMessage()). instruções ..... ela irá causar o término da aplicação.. O mais importante é herdar de Exception e fornecer uma identificação diferente. acrescentar métodos. // instruções serão executadas se exceção não ocorrer . campos de dados e construtores como em qualquer classe. Os blocos cath recebem tipo de exceção como argumento. Para criar uma classe que represente sua exceção. Apenas um bloco catch é capturado..Exception: class NovaExcecao extends Exception { } Não precisa de mais nada. 35 . Ocorrendo uma exceção no try. Se em algum lugar ela for capturada.println("Erro: " + ex. 4.lang.. ela irá descer pelos catch até encontrar um que declare capturar exceção de uma classe ou superclasse de exceção.exceção.. sendo seguido por um ou mais blocos catch(TipoDeExcecao ref) e seguido ou não de um bloco finally. } .. o controle pode ser recuperado. Pode-se. } catch (ExcecaoContabil ex) { System.8..

b. // retorna exceção que causou esta exceção String toString().Uma observação importante é que um bloco catch também pode gerar exceções. class Principal { public static void main(String args[]){ Fracao a. assim.out. Exception(String message). a. uma exceção do tipo da específica jamais será capturado. existem exceções que não são verificadas em tempo de compilação. Subclasses de RuntimeException representam erros de lógica de programação que 36 . // retorna nome da exceção e mensagem void printStackTrace(). System. presentes nas classes Runtime Exception e Error da API. O compilador detecta esta situação e não compila o código. as classes mais específicas devem aparecer primeiro. // imprime detalhes sobre exceção As Exception são exceções verificadas em tempo de compilação. Os principais métodos de Exception são: String getMessage(). b=new Fracao(2. Porém. }cath(DivisaoPorZero minhaexcecao){ System. pode-se fazer um throw dela mesma ou mudar a classe da exceção e continuar propagando (throw de outra exceção). System.out.c.divisao(b).out. try { c=a. O compilador exige que sejam capturadas ou declaradas pelo método que potencialmente as provoca.print("Esta e' a fracao b: ").mostra(). Exception(String message. a=new Fracao(5. } } } Os principais métodos construtores de Exception são: Exception(). havendo uma exceção que não se conseguiu tratar.mostra(). Trowable cause). se entre os blocos catch houver exceção da mesma hierarquia de classe. // retorna mensagem passada pelo construtor Trowable getCause().3).println("Nao posso dividir por zero").mostra(). c.0). ou fazer a reparação do erro e jogar uma exceção para que seja completada por outros métodos. As subclasses de Error não devem ser capturadas (são situações graves em que a recuperação é impossível ou indesejável). Porém. caso contrário.b.print("Esta e' a fracao a: ").

ou seja. Por exemplo. Paralela: Execução em vários processadores que compartilham uma memória. o computador é capaz e executar diversas tarefas ao mesmo tempo. Cada um desses sistemas tem o seu tipo de multitarefa. Podem ser capturados. PROGRAMAÇÃO CONCORRENTE. que depende mais dos periféricos de I/O que do processador. preemptiva ou não. mas. também conhecida como execução paralela. e a parte de interface com o usuário. Programação concorrente é um modelo de programação onde vários processos colaboram para atingir um determinado objetivo. devem ser corrigidos. existe mais de um fluxo de controle ativo. pode ser executada em outra thread. Java tem o suporte a multitarefa embutido na linguagem: Um programa Java pode possuir mais de uma thread. para designar a programação paralela e a programação distribuída.devem ser corrigidos. com ou sem multiprocessamento. A execução de unidades concorrentes admite as seguintes possibilidades: Pseudo-paralela: Execução em um único processador. como o Windows. Concorrência relaciona-se com fluxo de controle: em um programa. não significa execução simultânea. 37 . preferencialmente. OS/2 e Unix. sem compartilhamento de memória. podem ser escritos em uma thread. que em geral demandam muito tempo do processador. A maior parte dos sistemas operacionais hoje no mercado dão suporte à multitarefa. cálculos extensos. Execução concorrente. A programação concorrente é usado. A programação concorrente tem sido usada freqüentemente na construção de sistemas operacionais e em aplicações nas áreas de comunicação de dados e controle industrial. Distribuída: Execução em vários processadores independentes.

não disponíveis em C e C++.O programa geralmente não possui controle sobre a ordem e o tempo de execução das unidades concorrentes.lang.lang. oferecendo ao programador Java recursos poderosos. e thread nada mais é do que isso: uma linha de execução dentro de um processo. Sistemas operacionais.Runnable. é criado pelo sistema operacional um processo. 38 . chamado multi-threading. Processadores distribuídos. Quando uma programa é "rodado". Correio eletrônico. 5.1. Implementar aplicações distribuídas. cada thread designando uma parte de um programa que pode ser executado simultaneamente com outras threads. Múltiplos processadores. No momento da criação do processo existe uma única linha de execução nele. Existem duas maneiras básicas de se criar uma thread em Java: herdando da classe java.Thread ou implementando a interface java.). vamos mostrar como um programa funciona: todo programa possui uma área de dados e uma área de texto (que é a área que contém as instruções do programa). Diferentes threads no mesmo programa compartilham um ambiente global (memória. processador. O QUE SÃO THREDS E PARA QUE SERVEM ESSAS THREDS? Antes de falar em threads. Aumentar confiabilidade e disponibilidade. Simuladores. que nada mais é do que o programa sendo executado. explicar o que são e para que servem. registradores. Obter especialização de serviços. Os objetivos da programação concorrente são: Reduzir o tempo total de processamento. Esse recurso. etc. Java é uma linguagem de programação que permite ao programador especificar que os aplicativos executem threads.

. acontece quando se tem várias threads (isto é. O sistema operacional de qualquer plataforma multi-tarefa (exemplo: Windows.lang. Em um ambiente multi-processado (plataforma com vários processadores) as várias threads podem ser escalonadas para diferentes processadores e neste momento se tem uma aplicação verdadeiramente paralela. Linux.. verifica-se que as saídas de cada execução são diferentes uma das outras devido à concorrência da aplicação.lang. executando a classe principal várias vezes. Existem basicamente duas formas de se criar uma thread em Java: herdando da classe java. várias linhas de execução) dentro da mesma aplicação (processo). mas com processos.lang.Runnable (a classe java.) faz esse mesmo escalonamento só que não com threads. Ao contrário de outras linguagens de programação que utilizam o conceito de threads através de bibliotecas específicas. como o próprio nome sugere. Em um ambiente mono-processado esse paralelismo é então simulado.. Threads Herança 39 .Thread implementa esta interface). Ao compilar o trecho de código abaixo. Abaixo seguem dois exemplos de como criar threads bem simples que imprimem mensagens em um buffer. portanto elas "rodam" sobre a mesma área de texto .Thread ou implementando a interface java. alguma entidade (no caso de Java essa entidade é a Máquina Virtual Java) fica responsável por escalonar o procesador para as várias threads do processo. com as várias threads atuando ao mesmo tempo.A programação multi-thread. Isso é possivel porque todas as threads compartilham a mesma área de processo. Java incorpora este conceito dentro da própria linguagem e por isso não é necessário linkar seu programa multi-thread com nenhuma outra biblioteca externa.

Caso o programador não implemente este método. 7 } 8. uma implementação default que não faz nada é fornecida pelo compilador. 4-6) Construtor que irá inicializar as variáveis do objeto. 3. 13.1. i < 20. this. mas normalmente o programador terá a necessidade que sobrecarregar este método colocando nele o código que deverá ser executado pela thread. public class ThreadHeranca extends java.buf = buf. } 17. for(int i=0. buf. this. 11.Thread{ 2. 6. private StringBuffer buf. sleep((long)(Math. catch (InterruptedException ie) 15. Este é o método que será chamado quando a thread começar a ser executada.texto = texto. 7) Esta é uma das partes mais importantes da criação de uma thread. } 16.append(texto).Thread.lang. 3) Referência ao objeto String que contém o texto que será inserido no buffer. } 14.random() * 100)). 2) Referência ao buffer compartilhado que irá ser alterado pela thread.} 1)Uma das formas de se criar uma thread é herdando da classe java. String texto){ 5. private String texto. 4. try { 12. public ThreadHeranca(StringBuffer buf.lang. i++){ 10. 40 . public void run(){ 9.

Runnable. Para isso basta fazer uma pequena modificações no exemplo anterior. ThreadInterface substituindo a classe ThreadHeranca com uma explicação das mudanças em relação à anterior: 1: public class ThreadInterface implements Runnable{ 2: private StringBuffer buf. 7-9) Agora cada uma das threads tem a sua execução iniciada. A explicação para isso é que este método é implementado pela classe java. 3) Criação do buffer que terá referências em cada thread. A resposta é que se fizérmos isso o método main() iria esperar o retorno do método run() e não haveria assim concorrência nenhuma.8-9) Esta thread irá acrescentar 20 vezes o conteúdo do objeto String texto no final do buffer. a execução de cada uma delas ainda não foi disparada). Java através da interface java. 1-2) Declaração da classe e do método main. O leitor pode estar se perguntando por que não chamamos diretamente o método run() que contém o código que queremos executar. 10) Este código é apenas para fazer este método "esperar" que as threads terminem a sua execução (não usamos o método sleep() porque estamos em um contexto estático). seria uma chamada a uma função normal como outra qualquer. Note que chamamos o método start() que não foi implementado pelo programador.lang. 41 .Thread e nada mais é do que uma chamada à Máquina Virtual Java para ela criar uma thread que executará concorrentemente o método run() que implementamos anteriormente.lang. 10-12) A thread é colocada para dormir por um tempo arbitrário para dar a aplicação um aspecto de imprevisibilidade (e também para dar tempo à máquina virtual de escalonar as outras threads para executar já que este código é muito rápido). 11) Finalmente imprimimos o resultado do buffer na tela para comprovarmos que as três threads executaram seus respectivos códigos concorrentemente. 4-6) Criacão das threads (elas apenas foram criadas.

inter3.toString()).append(texto). o código que será executado pela thread. i < 20. Agora não mais herdamos da classe java. 10. 42 . 6. StringBuffer buf = new StringBuffer().texto = texto. System.start(). public ThreadInterface(StringBuffer buf. inter1.Runnable. "thread 1\n")). i < Integer. } } Thread inter1 = new Thread(new ThreadInterface(buf. public class Principal2{ 2. 5. j < Integer.3: 4: 5: 6: } 7: 8: 9: 10: } } private String texto.start(). 7. Thread inter3 = new Thread(new Threadinterface(buf.MAX_VALUE/10. for(int i=0. i++) { buf. "thread 2\n")). Após isso podemos usar este objeto da mesma forma que fizemos com o exemplo anterior. public static void main(String []args){ 3. inter2. Esta interface apenas requer que implementemos o método public void run() que conterá. public void run(){ for(int i=0.lang.start().Thread passando como parâmetro um objeto que implementa a interface Runnable (que é o nosso objeto ThreadInterface).lang. j++).Thread mas ao invés disso implementamos a interface java. this. i++). 7-11) Este código é idêntico ao exemplo anterior. } Esta é uma das poucas mudanças a se fazer na classe. assim como no exemplo anterior. 4.lang. String texto){ this.buf = buf. Thread inter2 = new Thread(new ThreadInterface(buf. 4-6) Esta é a única mudança neste código. Principal2 1. Agora nós criamos um objeto java.out. for(int j=0. 11. 1-3) Este código é idêntico ao exemplo anterior. 9. 8.MAX_VALUE/600. "thread 3\n")).println(buf.

CAY. uma outra forma de se implementar sincronização é através do uso de uma construção de mais alto nível chamada monitor. ANDRE AUGUSTO. 2003 HORSTMANN. Acessado em: 01/06/2007 CESTA. Existem duas maneiras de se fazer isso: A sincronização de competição que ocorre quando duas ou mais threads competem pelo mesmo recurso compartilhado. como programar. Vinculação Estática e Dinâmica.pdf. 2004.br/research/master/Orlando_Figueiredo/tese.usp.5. E a sincronização de cooperação.pdf. Disponível em: http://www. visibilidade.ufscar. RINO. mas sim a comunicação entre elas para que uma atue num momento específico que depende de uma ação ou estado da outra. Java.br/~if686/aulas/aula04_nomes. 2004 43 .br/~lucia/notasDidaticas/LingProgram/SinteseEstendida. MAIO 2004. Disponível em: http://www. Disponível em: http://www. Algumas bibliotecas que suportam threads oferecem este recurso através de mecanismos conhecidos por semáforos.icmc.dc. H. que ocorre quando o aspecto mais importante de duas ou mais threads não é a competição por um recurso. REFERENCIAS BIBLIOGRÁFICAS. ORLANDO.pdf.cin. Big Java. LUCIA HELENA MACHADO. Acessado em 31/06/2007.java. e por isso precisam se comunicar de alguma forma para que os dados não se tornem inconsistentes devido à concorrência das threads no acesso ao recurso. Limitação de alcance. muitas vezes é necessário sincronizar essas linhas para evitar que os dados compartilhados entre elas se tornem inconsistentes ou então que essas linhas atuem em momentos errados. 01/06/2007.ufpe.2. CAVALCANTI. Acessado em: 01/06/2007 FIGUEIREDO. 31/05/2007. SINCRONIZAÇÃO No momento que duas threads são disparadas dentro de uma aplicação. A Linguagem de Programação JAVA. No caso de Java a própria linguagem incorpora o conceito de monitores através da palavra-chave synchronized. M. DEITEL. GEORGE DARMITON DA CUNHA.

44 .