You are on page 1of 140

Sebenta da Disciplina de Introdução à Programação

Índice de Matérias

1- Conceitos Básicos de Ciências da Computação.................................................................................................... 4
1.1 - Motivação ............................................................................................................................................................ 4
1.2 - Resolução de Problemas .................................................................................................................................... 4
1.2.1 - Criação de Algoritmos ................................................................................................................................. 5
1.2.2 - Técnicas de Descrição de Algoritmos ......................................................................................................... 7
1.3 - Do Algoritmo ao Programa ................................................................................................................................ 15
1.3.1 - Representação Digital da Informação ....................................................................................................... 15
1.3.2 - Componentes de um Computador ............................................................................................................ 16
1.4 - Linguagens de Programação ............................................................................................................................ 17
1.4.1 - Tradução de Linguagens de Programação ............................................................................................... 17
1.5 - A Linguagem Java............................................................................................................................................. 18
1.5.1 - Compilar um Programa em Java............................................................................................................... 18
1.5.2 - Exemplo de um Programa em Java .......................................................................................................... 19
1.6 - Exercícios Práticos ............................................................................................................................................ 19
2 - Introdução as noções de Classe e Objecto.......................................................................................................... 21
2.1 - Conceito de Objecto e Classe ........................................................................................................................... 21
2.2 - Exercícios .......................................................................................................................................................... 25
3 - Conceitos básicos de programação em Java....................................................................................................... 27
3.1 - Identificadores ................................................................................................................................................... 27
3.2 - Palavras Reservadas ........................................................................................................................................ 27
3.3 - Símbolos e Valores ........................................................................................................................................... 28
3.4 - Variáveis............................................................................................................................................................ 28
3.4.1 - Variáveis de Instância: Atributos ............................................................................................................... 29
3.5 - Tipos de Dados ................................................................................................................................................. 29
3.5.1 - Tipos de Dados Primitivos......................................................................................................................... 30
3.5.2 - Tipos de Dados Referenciados ................................................................................................................. 33
3.6 - Operadores e Expressões................................................................................................................................. 35
3.6.1 - Operadores de Atribuição ......................................................................................................................... 35
3.6.2 - Operadores Aritméticos............................................................................................................................. 35
3.6.3 - Operadores Lógicos .................................................................................................................................. 37
3.6.4 - Operadores Relacionais............................................................................................................................ 38
3.6.5 - Expressões................................................................................................................................................ 38
3.7 - Métodos............................................................................................................................................................. 39
3.7.1 - Método construtor sem argumentos.......................................................................................................... 40
3.7.2 - Invocação de métodos e passagem de parâmetros ................................................................................. 41
3.7.3 - Métodos construtores com argumentos .................................................................................................... 45
3.7.4 - Métodos selectores ................................................................................................................................... 47
3.7.5 - Métodos modificadores ............................................................................................................................. 48
3.8 - Estrutura de Aplicações em JAVA..................................................................................................................... 49
3.8.1 - Estrutura do programa principal ................................................................................................................ 49
3.8.2 - Visibilidade das Variáveis.......................................................................................................................... 50
3.8.3 - Entrada e Saída de Dados ........................................................................................................................ 50
3.8.4 - Definição de Novas Classes ..................................................................................................................... 53
3.8.5 - Utilização de classes existentes em JAVA................................................................................................ 54
3.8.6 - Comentários .............................................................................................................................................. 56
3.8.7 - Paragrafação / Indentação ........................................................................................................................ 56
3.9 - Exercícios Práticos ............................................................................................................................................ 57
4 - Instruções de Controlo ......................................................................................................................................... 58
4.1 - Selecção............................................................................................................................................................ 58
4.1.1 - Selecção Simples: if............................................................................................................................... 58
4.1.2 - Selecção Em Alternativa: if-else....................................................................................................... 60

© Escola Superior de Tecnologia de Setúbal 2005-2006 Página 1

...................... 85 5...........................................3 ...........3 .................................................... 85 5..................................O Operador de Auto-Referenciação this .......................................................... 116 7. 72 4............................2................................................................................... Anexo I – Exemplo Introdutório em Java ......................................................................................................................................Introdução................................... 86 5.....................4 ...................Algoritmo QuickSort..................................................................Passagem por Parâmetros Referenciados......................................................................Tabela Unidimensional ................ 121 8.....................................................................1 ............ 117 7....6.......... 114 7..................................................................................2..........2...........Tabela Multidimensional........................................................................................................................................................................................1 ....................Passos para utilizar uma tabela .... 130 9..................... 114 7............................................................................................................................... 127 8................................................................... 70 4..2 ................ 90 6.......2........................................................................Ordenação por selecção ............................ 114 7.................. 129 9 ................................................ 110 6.......... 68 4..................Classe Vector .................2 .... 110 6. 108 6..................... 107 6....................................................................................................Passagem de tabelas como parâmetros de métodos ...............................................................2.......................... 134 11 ...............................2 ................................................................................3 ......................................................... 87 5.............Motivação .................................................................................2.....4 .............................Procura Sequencial ....3 ............................... 110 6..................................... 92 6................................................. 68 4................................... 92 6.........................................................................Sobrecarga de Métodos ..............................Exercícios práticos .........................................................................................................................1................3 .......................................................................................................................................................................Instrução de Repetição do-while ......................2 .............................................................Com Sentinela............................................................................................................................................................................ 130 9..... 82 5............Bibliografia ...................................................................................Alguns métodos da classe Vector.................................................. 132 10 ........... 119 8 .....................................................................................................................................................................Tabelas de Objectos........................................................................................................................................Introdução ..........................................................1 ................................................ 85 5..........................Exercícios Práticos ........................7 ........5 ....................................6 ..Tabelas...................................7 ....................................................... 82 5.......................... 138 © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 2 ............................................Exercícios Práticos ...................................................................................................2 ............................................Definições................................................................Modificadores de visibilidade..........................................ShellSort ...............6 ..............................................................................................6 .............................................Encapsulamento.........................................................2 ....................................................4 ..........................5 .............................1 .........2............5 ...............1 ................................................................................................................................................................................................Variáveis de Instância e variáveis de Classe ...... 88 6 ............................... 92 6..................................................Instrução de Repetição while ...................... 121 8....................................... 124 8..........................................2 .............................Simples...............................................................................................................Procura Binária.... 114 7......................1 ...........................................................3 ........Tópicos Avançados de Classes ................................... 65 4...............Exercícios práticos ...3 .......Introdução ......................................................Recursividade............................................................................. Sebenta da Disciplina de Introdução à Programação 4.................................................................................................................. 136 12 ..................1 ..................... 96 6..........................................1 ..............6..................................................................................................................................... 76 5 ........................................................................................4 ................1 ................... 111 7 .................................... 126 8........................Algoritmos de Procura/Pesquisa .......................Algoritmos de Ordenação.........................................2 .......Repetição ............................................. Anexo III ..........Introdução................................................................................................................................................ Anexo II – Glossário......................... 122 8..................................Exercícios práticos .........................................case .........Instrução de Repetição for ..................................2 .....................................Selecção Múltipla: switch ....2 ............... 90 6..........Exercícios Práticos ...........BubbleSort........................

pois novas palavras poderão ser adicionadas ao glossário que possivelmente esclarecerão outros colegas com dúvidas semelhantes à sua. visto terem sido utilizados os respectivos acetatos como referência para alguns dos conteúdos aqui utilizados. Caso não esteja lá definida a palavra que procura. Ao notificar o professor estará também a contribuir para melhorias futuras no documento. por favor dirija-se ao glossário que é apresentado em anexo para descobrir uma possível definição para o mesmo. não hesite em questionar os colegas ou professores para melhor ficar esclarecido. sempre que não entender o significado de determinado termo. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 3 . para além de ter sido elaborado pelos professores já mencionados. conta com a participação dos docentes da cadeira de IP dos anos lectivos de 2000/2001 até 2004/2005. Sebenta da Disciplina de Introdução à Programação Nota: Ao longo da leitura deste documento. A sebenta do ano lectivo 2004/2005 foi reestruturada e melhorada. Este documento.

1 Sintaxe de uma linguagem é o conjunto de regras que define as relações válidas entre componentes da linguagem.Motivação Nas sociedades modernas todos os sectores de actividade dependem directa ou indirectamente do apoio dos computadores. Um algoritmo pode ser definido como um conjunto finito de instruções bem definidas e não ambíguas. Pode dizer-se que os programas fornecem conhecimentos e estratégias de resolução de problemas. Conceitos Básicos de Ciências da Computação 1. ƒ estado final. como programadores. Sebenta da Disciplina de Introdução à Programação 1. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 4 . pois cada problema é um caso diferente. Quando se faz a análise de um problema é importante considerar três componentes: ƒ estado inicial.Resolução de Problemas O objectivo de um programador. cabe-nos a nós. mas sim na procura de soluções para o problema em causa. ƒ a transformação. Em seguida. instruções que os computadores devem executar. o que se pretende obter como resultado. A programação é a “arte” de analisar um problema e encontrar uma sequência de acções (um algoritmo) capaz de o resolver correctamente. a forma como a partir de um problema se consegue obter a solução. que executadas por uma determinada ordem resolvem um problema. a principal dificuldade não reside na sintaxe1 ou na semântica2 da linguagem de programação utilizada.1 . umas ainda serão mais ou menos exaustivas. o problema deve ser analisado no sentido de procurar soluções para o mesmo. Esta sequência de passos é chamada de Algoritmo. e do Software. Contrariamente ao que se possa pensar. A resolução de problemas é uma tarefa para a qual não há receitas nem fórmulas. saber averiguar qual das soluções encontradas se adequa melhor às necessidades da tarefa que temos em mãos. É necessário que encontremos uma sequência de passos que permitam que o problema possa ser resolvido de maneira automática e repetitiva. O funcionamento dos computadores depende da conjunção do Hardware. Para que se possa encontrar uma boa solução para um problema. 1. Umas serão mais correctas ou terão melhor desempenho que outras. ou seja. Para que se possa resolver um problema é necessário que seja primeiramente encontrada uma maneira de o descrever de forma clara e precisa. Uma receita não é mais do que uma descrição de passos ou acções que fazem a combinação de um conjunto de ingredientes com vista a obter um produto final (bolo). é o de resolver um ou mais problemas. que especifica os passos necessários para transformar o estado inicial no estado final.2 . podemos afirmar que o passo fundamental na criação de um programa é a definição de um algoritmo isto é. na maioria das vezes. componentes físicos. Exemplo: Vamos supor que temos como tarefa resolver o problema da confecção de um bolo. quando escreve um programa. isto é quais os dados de entrada do problema. tal como podem ser inúmeras as soluções que o resolvem. é necessário começar pela sua compreensão. 2 Semântica de uma linguagem define o significado de cada frase da linguagem. Muitos dos erros dos programadores são causa de uma deficiente compreensão e análise do problema. Assim.

1. visualizar a solução para algo mais amplo e mais genérico. como pela dificuldade do problema a resolver. estamos sempre a utilizar uma técnica que se chama “Divide and Conquer” . Nesta abordagem o problema complexo é dividido em problemas mais simples e procura-se soluções para esses problemas mais simples. que trabalhando em conjunto nos fazem chegar à solução que nos interessa. Abordagens Top-Down e Bottom-Up Existem duas abordagens para a resolução de problemas.2.1 Aquecer o forno à temperatura desejada 2.Criação de Algoritmos A criação de algoritmos é fundamental no desenvolvimento de programas de computador.1 .3 Juntar a farinha e o fermento. 1.4 Colocar a massa numa forma 2. significa que temos de dividir um problema em partes menores (ou subproblemas) de modo a que seja mais fácil a sua resolução © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 5 . ou seja. Pode até utilizar-se um misto destas duas abordagens. apelidade de Bottom-Up que parte da base para o topo. Independentemente do sentido em que procuramos a solução.2 Colocar no forno e esperar que o bolo esteja cozido ƒ Estado final: um bolo Afinal não é só na programação de computadores que podemos aplicar algum método ou tipo de raciocínio para resolver problemas! Com este exemplo vimos aplicada a um caso da vida quotidiana exactamente a mesma ordem de pensamento que iremos seguir daqui por diante na implementação de programas de computadores. ou seja. A complexidade tanto pode ser gerada pela dimensão. partindo de problemas pequenos.1 Bater a margarina e o açúcar até obter um creme. é a conhecida como “abordagem do topo para a base” (abordagem Top-Down). desde que no fim consigamos atingir uma boa solução para o problema.1. por partir de um problema geral e procurar chegar aos detalhes. 1. Cozinhar o bolo 2. tem de correr as etapas todas uma por uma com o objectivo de no fim ter conseguido uma média de tempos inferior à dos outros corredores! Exemplo: Fazer sumo de laranja Aplicando o método anteriormente descrito. Misturar ingredientes 1.1 . Sebenta da Disciplina de Introdução à Programação Analisando tudo o que é necessário para cumprir essa tarefa e tendo em conta os passos atrás mencionados. a mais utilizada.2. quais são os passos a seguir? ƒ Estado inicial: ingredientes (respectivas quantidades) ƒ Transformação: processo de confecção do bolo (Algoritmo) 1. Em qualquer uma delas está inerente um conceito que é a base de resolução de qualquer problema: a divisão em elementos de solução mais simples. Existe também a abordagem contrária. surgem dificuldades adicionais devidas há quantidades de aspectos que é necessário considerar no momento. Uma. Quando se trata de programas complexos.2 Adicionar os ovos 1. 1. Dividir para Conquistar. Ninguém ganha uma corrida só porque decide ganhar.

ƒ Testar o algoritmo ƒ Executar o algoritmo No entanto. isto é. largura -> largura. Cada variável é identificada por um nome.Produzir resultados correctos. altura -> altura Valores intermédias: area_base. nas mesmas quantidades tivéssemos bolos diferentes algo de errado se tinha passado) . Sebenta da Disciplina de Introdução à Programação Algoritmo: Lavar a laranja Partir a laranja ao meio Espremer a laranja Filtrar o sumo Servir o sumo O que se pode destacar com este exemplo é que cada passo é completado antes que o próximo comece. Uma variável é um lugar na memória do computador onde podemos colocar um valor. ou consultar o valor que lá está.2 . é impossível ouvir rádio sem primeiro o ligar. tendo em consideração que: -Para um mesmo conjunto de dados deve produzir sempre os mesmos resultados (se com os mesmos ingredientes. Identificação das variáveis que o algoritmo vai manipular: Dados de entrada: comprimento -> comp. Exemplo: Elaborar um algoritmo que calcule a área total das paredes de uma caixa de secção rectangular a partir das suas dimensões. qualquer que seja o conjunto de dados legítimos utilizado. quando se concebem algoritmos para serem transformados em programas é importante exprimi-los utilizando acções que o computador seja capaz de executar: ƒ Receber e fornecer informação ƒ Guardar informação para posterior utilização ƒ Operações aritméticas ƒ Operações lógicas ƒ Escolher entre várias acções (selecção) ƒ Repetir um grupo de acções (repetição) Outro aspecto importante é que os nossos algoritmos vão ter que manipular valores.observar regras e limitações .1. fazendo-o em termos que possam ser executáveis pelo computador .2. area_lateral2 © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 6 . Para tal utilizam-se variáveis.eliminar ambiguidades (qualquer pessoa que o execute obtém os mesmos resultados) ƒ Construir o algoritmo.identificar todas as acções a realizar . Passos para elaboração de um algoritmo Quando pretendemos escrever um algoritmo é importante que se sigam um conjunto de passos: ƒ Compreender o problema ƒ Identificar os dados de entrada ƒ Identificar os dados de saída ƒ Determinar o que é necessário para transformar dados de entrada em dados de saída.usar a estratégia de dividir em problemas mais pequenos . area_lateral1. Como por exemplo. deve-se descrever todas as transformações necessárias para resolver o problema. estes têm que ser guardados em algum lugar. 1.

area_caixa = 2 * area_base + 2 * area_lateral1 + 2 * area_lateral2 3.1. Introdução dos valores iniciais 1. esses termos são geralmente um misto de palavras da nossa linguagem natural com palavras e notações típicas das linguagens de programação.2. Os fluxogramas são diagramas representativos do fluxo de acções de um programa.4.5. Representação gráfica de um algoritmo.1. Apresentação dos resultados 3. Outra maneira é usando pseudocódigo (exemplo calculo da área). Sebenta da Disciplina de Introdução à Programação Dados de saida: área da caixa -> area_caixa Algoritmo: 1. Pedir altura da caixa 1. A utilização de pseudocódigo permite ao programador expressar as suas ideias sem ter de se preocupar com a sintaxe da linguagem de programação. que representam os diferentes tipos de acções e seu encadeamento na sequência do programa (ver figura abaixo).4. o português como no exemplo do bolo). Ler largura 1.2 .1. em que os algoritmos são expressos directamente em linguagem natural (isto é. area_base = comp * largura 2. a forma como são descritos é um pouco livre. através de símbolos. O pseudocódigo é um código de escrita em que se utilizam termos convencionais para indicar as instruções do programa.Técnicas de Descrição de Algoritmos Os algoritmos não são directamente executáveis pelo computador. Existem várias técnicas para a descrição de algoritmos.2. Figura 1. area_lateral2 = largura * altura 2. Pedir largura da caixa 1.3. Os algoritmos podem também ser descritos utilizando fluxogramas. area_lateral1 = comp * altura 2. ainda que deva ser suficientemente exacta para que não haja qualquer ambiguidade. Pedir comprimento da caixa 1. Ler comp 1. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 7 . Uma maneira de descrever algoritmos é usando linguagem natural.3.2.6. Escrever area_caixa 1. Ler altura 2. Transformação 2.

Principais símbolos utilizados nos fluxogramas. No entanto. Exemplo Elaborar um algoritmo que calcule o quadrado de um número. Sebenta da Disciplina de Introdução à Programação Processamento em geral Leitura/Escrita de Dados Início/Fim de processamento Linha de fluxo Decisão condicional Escolha múltipla Subprograma Figura 2. para representar programas de média e grande extensão. Actualmente os fluxogramas não são efectivamente muito utilizados. Pseudocódigo Início Pedir valor de a Ler a Calcular quadrado de a result = (a*a) Escrever “O quadrado é:” result Fim © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 8 . talvez possam ser úteis para ajudar a visualizar melhor determinadas estruturas típicas de programação. Mas. tornam-se difíceis de concretizar.

2. Podemos dizer que qualquer programa pode ser construído através da combinação de 3 estruturas básicas: sequência. não havendo qualquer possibilidade de alterar a ordem de processamento dessas acções. Numa sequência é processado um conjunto de acções (ou instruções) em série.1 . Sebenta da Disciplina de Introdução à Programação Fluxograma Início Pedir a Ler a result = a*a Escrever “O quadrado é:” result Fim 1. O conjunto de acções é executado exactamente pela ordem em que as instruções estão indicadas. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 9 . Estruturas de controlo Uma estrutura de controlo é a unidade básica da lógica de programação.2. selecção e repetição.

decidir sobre a execução ou não de determinada acção ou optar entre duas alternativas expressas. o processo segue por uma de duas vias. dependendo do valor lógico (verdadeiro ou falso) da expressão que é avaliada no início da estrutura. Ou seja. Sebenta da Disciplina de Introdução à Programação Uma estrutura de selecção (ou decisão) é uma estrutura que permite. com base numa condição. Pseudocódigo Início Pedir valor a Ler a Pedir valor b Ler b Se a ≠ 0 então Calcular o valor de x (ax+b=0) Escrever valor de x Senão Escrever “Não há zero” Fim © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 10 . Falso Verdadeiro Falso Verdadeiro Expressão Expressão Exemplo Elaborar um algoritmo que calcule o zero da equação ax+b=0.

” Fim Exemplo Elaborar um algoritmo que verifique qual o maior de dois números. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 11 .b/a Escrever Escrever “Não valor de x Existe zero. Sebenta da Disciplina de Introdução à Programação Fluxograma Início Pedir Ler a Ler ab Pedir Ler ab Ler b Não a≠0 Sim x= .

Sebenta da Disciplina de Introdução à Programação Pseudocódigo: Início Pedir “Introduza dois números” Ler valor 1 Ler valor 2 Se valor1 > valor 2 então Escreve valor1 “é maior” Senão Se valor1 < valor 2 então Escreve valor2 “é maior” Senão Escreve “valores iguais” Fim_Se Fim_Se Fim Fluxograma: Início Pedir Ler dois a valores Ler valor 1 Ler valor 2 Não Não valor 1 > valor 2 valor 1 < valor 2 Sim Sim Escrever Escrever Escrever valor 1 é maior valor 2 é maior valores iguais Fim © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 12 .

isto é na primeira situação a acção só é realizada se a condição tiver o valor lógico verdadeira. a mesma acção é expressa repetidamente enquanto o resultado da expressão lógica se mantiver verdadeiro. A diferença é que logo à partida é especificado o número de ciclos (ou iterações) que serão efectuados. No entanto. Sebenta da Disciplina de Introdução à Programação Por último falta falar das estruturas de repetição (também conhecidas por ciclos). pode repetir-se um conjunto de acções um determinado número de vezes ou enquanto se quiser. isto é o número de vezes que a acção é realizada. no segundo caso a acção é sempre realizada qualquer que seja o valor lógico da expressão pois este só é verificado depois da acção ter sido realizada. Neste caso também é necessário tomar a decisão com base no valor lógico de uma expressão. com um determinado número de instruções. uma vez que. mediante uma expressão de controlo. Estas estruturas apresentam grandes vantagens para a programação em termos de economia de escrita de código. Nas estruturas de repetição o teste da expressão lógica pode preceder a acção ou pode suceder a acção. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 13 . Expressão Verdadeiro Falso Expressão Verdadeiro Falso Expressão Verdadeiro Falso Esta última estrutura de repetição é idêntica às duas anteriores.

O segundo utilizador só para de introduzir número quando acertar. Sebenta da Disciplina de Introdução à Programação Exemplo Elaborar um algoritmo em que um utilizador introduz um número e outro utilizador vai tentar advinhar esse número. Algoritmo Fluxograma Início Pedir a Início Ler a (número a acertar) Repetir Pedir b Ler b Até que a = 0 Pedir a Escrever “Acertou” Fim Ler a Pedir b Ler b Não a=b Sim Escrever “Acertou” Fim © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 14 . introduzindo números até a acertar.

. Quer-se com isto dizer.. e assim sucessivamente. Consoante o número de bits ou de bytes podemos dar nomes diferentes às unidades (à semelhança do que acontece no sistema métrico com metros.3. mas em qualquer outra. Sebenta da Disciplina de Introdução à Programação Não existe consenso entre os especialistas sobre qual é a melhor maneira de representar um algoritmo. com 1 bit conseguimos representar 21 = 2 números. Outra vantagem da escrita de algoritmos em pseudocódigo é que esta forma de abordagem presta-se a uma aproximação sucessiva à versão final do programa. A unidade básica deste sistema é o bit. Observemos a tabela seguinte: Num. pode-se ir progredindo por fases.. . etc.. denominados bytes. 1.). Actualmente a maneira mais comum de representar é através de pseudocódigo. utilizando o sistema de numeração Binário.. Decimal 1 bit 2 bits 3 bits 0 0 00 000 1 1 01 001 2 10 010 3 11 011 4 100 5 101 6 110 7 111 . . com 2 bits conseguimos representar 22 = 4 números distintos.. com 3 bits representam-se 23 = 8 números. Vejamos a tabela seguinte: Unidade Conversão Símbolo SI 1 bit N/A b 1 byte 8 bit B 1 Kilobyte 1024 byte KB 1 Megabyte 1024 Kilobyte MB 1 Gigabyte 1024 Megabyte GB © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 15 . .1 ..Representação Digital da Informação Os computadores armazenam e processam toda a informação. O sistema de numeração binário é um sistema de dois estados. sem ter de se elaborar um novo algoritmo. A utilização de pseudocódigo tem a vantagem de podermos utilizar um texto escrito dessa forma como base para a escrita de um programa. ou seja. revendo o pseudocódigo e substituindo-o progressivamente por termos e sinais próprios da linguagem de programação. A conversão de números do sistema binário para o sistema decimal também é simples. centímetros. vejamos o seguinte exemplo: 111 = 1*22 + 1*21 + 1*20 = 7 101 = 1*22 + 0*21 + 1*20 = 5 Do sistema decimal para o sistema binário. não apenas numa determinada linguagem de programação. decímetros.. representados pelos valores 0 e 1. basta fazer divisões sucessivas por dois e aproveitar o resto da divisão inteira: 7 / 2 = 3 e o resto da divisão é 1 3 / 2 = 1 e o resto da divisão é 1 1 / 2 = 0 e o resto da divisão é 1 Os computadores armazenam dados em séries de 8 bits.Do Algoritmo ao Programa 1. Como podemos verificar na tabela N bits representam 2N itens distintos. que pode assumir apenas dois estados distintos.3 .

2 . Periféricos Unidade Central de Processamento Periféricos De Entrada De Saída (CPU) Memória Memória Principal Secundária Figura 3. por exemplo. rato. e uma parte não física (software). tais como o octal e o hexadecimal. 1.Componentes de um Computador Um computador tem uma parte física (hardware). uma de cada vez. Componentes de um computador. interpretar e executar instruções. subtracção e Unidade Aritmética/Lógica outras operações aritméticas. Esta unidade executa continuamente um ciclo que consiste nos passos seguintes: • Aquisição (obtenção de uma instrução) • Descodificação (determinação do tipo de instrução) • Execução (execução da instrução). memória etc. bem como a comparação de valores) e toma decisões Determina a próxima instrução a ser Unidade Controle executada (controla todos os passos do processamento) Pequeno número de registos com grande Registos velocidade de acesso. constituídas pelos programas. teclado. A função básica do CPU é obter.. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 16 . Componentes da CPU. O CPU é constituído por: Efectua cálculos (adição. O componente mais importante do computador é a unidade central (CPU – Central Processing Unit).3. constituída pelo monitor. Sebenta da Disciplina de Introdução à Programação Existem outros sistemas de numeração para além do decimal e do binário. para armazenamento de resultados temporários Figura 4.

• dispositivos de saída: monitor.4 .. disquetes. rato. • dispositivos de entrada/saída: modem. entre outros.. 1. CD-Roms. 1. Célula número 1. ƒ Quando se escreve um novo valor numa célula de memória. cartões de memória usados nas máquinas fotográficas digitais. Há muitas linguagens que se podem incluir nesta categoria: C. No entanto. As instruções são constituídas por 0s e 1s. 1024 Figura 5. Lisp. como por exemplo: • dispositivos de entrada: teclado.4. a sua representação gráfica poderia ser a seguinte (em que os números abaixo da tabela de células representam os índices que identificam cada célula. 512 . Prolog. Os programas são escritos utilizando linguagens de programação. gigabytes (GB – 1024 MB ou 1024000000 bytes) Supondo que tínhamos uma memória RAM de 1MB. Sebenta da Disciplina de Introdução à Programação Outro elemento fundamental é a memória central. 256 .. ƒ Pode ser imaginada como sucessão de células (ver figura abaixo). O armazenamento permanente da informação é conseguido em dispositivos de armazenamento secundário: ƒ Armazém de dados ligado à memória principal ƒ Mantém o conteúdo mesmo com o computador desligado – memória não volátil – armazenamento permanente (também se diz persistente) da informação Estes dispositivos de armazenamento secundário persistente são os Discos rígidos. ƒ Linguagens de Alto Nível: são linguagens mais próximas das linguagens humanas e. também conhecida por RAM (Random Access Memory). ƒ Linguagens Assembly: são linguagens com características semelhantes às das de máquina.Tradução de Linguagens de Programação Um programa é fornecido ao computador para que este o possa executar.. Representação gráfica da memória central de um computador (RAM) Para além da CPU e da memória central. pelo que é necessário proceder à tradução do programa. 2. perde-se o valor que anteriormente lá estava. ƒ A capacidade da memória é expressa no número de bytes que ela consegue armazenar: kilobytes (KB – 1024 bytes).Linguagens de Programação Para que um computador possa executar determinada tarefa. C++ e Java.. 256.. megabytes (MB – 1024 KB ou 1024000 bytes). Há diversos níveis de linguagem de acordo com as afinidades que apresentam com as linguagens humanas: ƒ Linguagens Máquina: são utilizadas para comandar directamente as acções do computador. é necessário que lhe seja fornecido um programa. É uma área de armazenamento de informação que apresenta as seguintes características: ƒ Perde o conteúdo quando se desliga o computador – memória volátil. DVDs. impressora. Pascal. etc): z a 12 x 0 1 2 3 . por isso.. são mais fáceis de utilizar do que as outras.1 . diferindo apenas por usarem nomes simbólicos em vez de sequências de 0s e 1s. os computadores só entendem linguagem máquina. existem diversos tipos de dispositivos que permitem a comunicação entre o computador e o utilizador. e manipulam directamente entidades dentro do computador. Para efectuar essa tradução utilizamos © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 17 .. ƒ Cada célula de memória armazena um único valor. . FlashDrives.

Compilador Java mas sim de um código intermédio. Os compiladores são programas que fazem a tradução do código fonte (escrito numa linguagem de alto nível) para código executável (em linguagem máquina). essa interpretação Bytecode Java é feita pela JVM (Java Virtual Machine). Os bytescodes não podem ser executados directamente nos diversos processadores. No entanto. Sebenta da Disciplina de Introdução à Programação compiladores. São necessários interpretadores.1 . é transformado num conjunto de Tradução bytes formatados – designados de bytecodes. Pode ter erros semânticos (ou seja. Processo de criação. Este problema fica resolvido considerando um computador virtual que se imagina capaz de executar um código constituído por instruções simples. 1. Existem versões diferentes desta Máquina Virtual para diferentes sistemas operativos (Windows. Neste caso. Código Fonte Java O “código-fonte”. O compilador Java não gera código executável mais sim bytecode. erros lógicos.A Linguagem Java JAVA é uma linguagem de programação orientada a objectos. um código que é independente do computador em que seja executado. Aos erros que ocorrem durante a execução do programa e que não podem ser detectados durante a compilação dá-se o nome de erros de execução.Compilar um Programa em Java Um dos objectivos principais do desenvolvimento do Java era a possibilidade de um programa escrito nesta linguagem ser executado em qualquer tipo de computador sem ter de ser alterado ou compilado novamente. etc). Interpretador Java) Figura 6.5.5 . quando passa pelo compilador. denominados por erros de compilação. A utilização do código intermédio tem a vantagem de permitir aos computadores criar programas que podem ser executados em qualquer tipo de computador. Execução Máquina Virtual Java (JVM. sem que tenham que se preocupar com as suas especificações. Unix. MacOS. A figura seguinte descreve o processo de criação. compilação e execução de um programa em Java. Esse código tem de ser interpretado pela chamada Máquina Virtual Java. desenvolvida pela Sun Microsystems. 1. Nesta fase não se trata ainda de “código-máquina”. compilação e execução de um programa em Java. derivados de um raciocínio errado que levou a uma solução também incorrecta). Desde © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 18 . Um programa sem erros de compilação não significa necessariamente que funcione como era desejado. este objectivo não pode ser atingido com a utilização de compiladores tradicionais. A primeira função dos compiladores é verificar se o código fonte que lhe é fornecido cumpre as regras sintácticas da linguagem em causa e assinalar os erros que eventualmente existam. que é um programa em execução no computador e que é responsável por executar programas Java. Linux. Esta linguagem resultou da ideia de criar uma linguagem que pudesse ser executada em qualquer tipo de computador. teremos de proceder a uma revisão do código e novos testes para que os erros sejam resolvidos. Solaris.

println(“Ola Mundo!”). (Nota: ºC = (ºF-32)*5/9. Exerc. Farenheit ou Kelvin. 4: a) Calcular o salário de um funcionário obtendo o valor e o número de horas semanais sabendo que se o número de horas for superior a 40. 7: Fazer uma chamada de um telefone público. 5: a) Calcular a média da nota de três exames introduzidos pelo utilizador.15) Exerc. 1: Descrever a sequência de passos necessários para pôr um carro a trabalhar. Exerc.Exemplo de um Programa em Java De seguida apresentada um programa simples em Java para imprimir uma pequena mensagem no ecrã . pelo menos o Java Standard Edition Software Development Kit (J2SE SDK) instalado no computador. em graus Celsius. 3: Calcular a nota de uma disciplina que é composta por 20% para o trabalho e 80% para o exame. as 40 horas são pagas pelo preço normal e as restantes pelo dobro do valor. 6: Dado um valor de temperatura. etc. 8: Somar um conjunto de 100 números inteiros. ºK = ºC+273. 1. Isto é: Até 40 horas – preço da hora Das 40 às 60 horas – dobro do preço da hora A partir das 60 horas – triplo da hora.Exercícios Práticos Escreva um algoritmo para resolver cada um dos seguintes problemas.5. Exerc. Deve considerar casos tais como “o telefone está ocupado”. Sebenta da Disciplina de Introdução à Programação que esse computador tenha a máquina virtual correspondente instalada. Exerc. public class OlaMundo { public static void main (String[] args){ System.out. } } Figura 7. b) Altere o algoritmo anterior de forma a receber só notas compreendidas entre 0 e 20 valores. “o telefone está avariado”. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 19 . O utilizador introduz as duas nota e é apresentada a nota final. 2: Verificar se um número se encontra entre 1 e 10. converter esse valor para as restantes unidades.2 . Exerc. Código fonte de um programa em Java. “o número desejado está interrompido”. qualquer programa Java poderá ser lá executado. Exerc.6 . Exerc. c) Alterar o algoritmo de forma a indicar se o aluno está aprovado (média superior a 10 valores) ou reprovado. Para criar programas em Java é necessário ter instalado no computador. 1. b) Altere o algoritmo anterior de forma a incluir um valor diferente para o número de horas superior a 60. Ola Mundo! Figura 8. Ecrã com o resultado da execução do programa.

através do seu número Exerc. Exerc. 14: Determinar se o número é primo. pensado por um colega. Exerc. 15: Receber uma sequência ordenada de números e determinar se um dados número aparece ou não na sequência. 11: Calcular o perímetro e a área de uma figura geométrica. Exerc. Exerc. 10: Determinar o resultado de uma expressão matemática que utilize os operadores: + e - Exerc. sabendo que a figura só pode ser um rectângulo ou uma circunferência. Após ter acertado informar o colega do número de tentativas efectuadas. 13: Descobrir um número entre 0 e 1000. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 20 . Qual a principal diferenção entre este algoritmo e o exercício 9. Sebenta da Disciplina de Introdução à Programação Exerc. 9: Receber uma seqência de números e determinar se um dado número (também recebido) aparece ou não na sequência. 12: Procurar uma nota de um aluno numa pauta.

turma. Aluno é todo aquele que é educado por um segundo elemento. no reino animal podemos definir vários grupos. Atributo define uma característica das futuras instâncias de uma classe. Tendo por base. “ é uma ideia ou noção que aplicamos às coisas. tais como carnívoros vs herbívoros. mais terra a terra. número. Têm um nome único dentro da mesma classe. mas sim orientarmo-nos para uma forma de pensar abstracta relativamente a qualquer problema. Uma classe não é mais que um grupo de pessoas. ao contrário do que se possa pensar. Mas como os agrupamos? Se pensarmos bem. A estas características chamamos atributos. Nome . Sebenta da Disciplina de Introdução à Programação 2. o de aluno.Conceito de Objecto e Classe Antes de introduzirmos os conceitos relacionados com a programação orientada por objectos convém relembrarmos algumas definições que nos acompanham no nosso dia a dia e as quais nos fazem falta daqui para a frente. Vejamos. curso em que está inscrito. Por exemplo. entre outras. o fazemos através dos seus atributos. Por exemplo. animais ou coisas. a definição de conceito e as abstracções que realizamos no nosso dia a dia. é nos possível definir classes. para dizermos que temos o conceito de barco apenas precisamos da capacidade de identificar uma instância de um barco. A linguagem de programação Java diz-se orientada aos objectos.A Ano – 1º Por outro lado. Ao conceito de Aluno chamamos de classe.EI Turma . de acordo com a definição de classe mencionada em cima. entre outras. pode transitar de ano. Estes são alguns dos comportamentos que um aluno pode desempenhar. Introdução as noções de Classe e Objecto 2. utilizando para isso conceitos do mundo real.João Número . em programação orientada por objectos. pode mudar de turma. Num paradigma de objectos. Mais. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 21 . peguemos num conceito que todos nós conhecemos. Ao consultarmos um dicionário constatamos que a definição de conceito é “ Tudo o que o espírito e a alma concebem ou entendem”. pode inscrever-se numa determinada turma. ou objectos da nossa consciência. não se procura uma nova forma de programar. ovíparos vs mamíferos. o aluno pode pagar propinas.2134 Curso . podemos afirmar que são várias as características de um aluno – nome. sabemos ainda que. chegamos à conclusão que ao definir por exemplo um grupo de animais.1 . normalmente numa instituição. das suas características.

adjectivos ou advérbios. Relembrando o conceito introduzido até aqui. Aluno1 é uma instância da classe Aluno. debaixo do mesmo conceito de Aluno. comportamentos e relações comuns. número. Os objectos colaboram com outros objectos através da troca de mensagens (invocação de métodos) para produzir resultados relevantes para o domínio do problema. Na figura em cima apresentada temos vários objectos representados: Classe Aluno Atributos Objecto Nome Número Curso Turma Aluno1 João 2134 EI A Aluno2 Ana 2133 EI A Aluno3 Pedro 2131 EI A Aluno4 Isabel 2135 EI A Assim. Podemos dizer que o objecto é uma instância de uma classe . assim uma categoria de objectos. Os objectos são normalmente descritos (através das classes) recorrendo a nomes. Sebenta da Disciplina de Introdução à Programação definindo aquilo que em orientação a objectos designamos de métodos. Uma classe é uma descrição de grupos de objectos com propriedades. pronomes. Os métodos representam funcionalidades específicas da classe. os objectos têm: © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 22 . Define. podemos afirmar que estamos na presença de vários alunos. Aproveitando a classe descrita anteriormente. nome. ou seja. Analisemos de seguida a seguinte figura: Isabel João 2135 2134 EI EI Turma A Turma A 1º Ano 1º Ano Pedro Ana 2131 2133 EI EI Turma A Turma A 1º Ano 1º Ano Temos vários elementos a serem identificados com as mesmas características. Visualizamos então vários objectos da classe aluno e verificamos que: Um objecto é um elemento de uma classe e possui as mesmas características e modo de funcionamento que os outros elementos (objectos) da mesma classe. curso e turma. Estamos perante aquilo a que em programação orientada por objectos chamamos de objectos.

Vejamos: O objecto Aluno1 pretende mudar da turma A para a Turma E. • Estado (atributos) – Cada um conhece e guarda os seus dados. turma Classe Aluno Atributos Objecto Nome Número Curso Ano Turma Aluno1 João 2134 EI 1 E Aluno2 Ana 2133 EI 1 A Aluno3 Pedro 2131 EI 1 A Aluno4 Isabel 2135 EI 1 A Aluno5 Rita 2137 EM 1 A Supondo que desejamos consultar o número de um aluno .objecto Aluno5. A utilização dos métodos passa normalmente por duas fases: • Definição . Supondo que uma nova aluna ingressa na escola. Imaginemos que um dos alunos pretende mudar de turma. ou seja os valores dos atributos. também definidos pela classe.definir o que e que um método sabe fazer no âmbito do objecto a que pertence. por indicarem algum tipo de acção. Permitem modificar ou interrogar os objectos relativamente ao seu estado actual.processo de enviar mensagens a um objecto para que determinado método do seu comportamento seja executado. • Que informação será necessária para criar essa instância? . • Invocação . número. É possível dizer neste momento que as classes não são mais do que uma espécie de moldes a partir dos quais criamos instâncias (objectos). • Comportamento – métodos. será necessário registar um novo aluno. que foram previamente definidos. O objecto Aluno1 invoca o método que altera a turma. curso. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 23 .Nome. Classe Aluno Atributos Objecto Nome Número Curso Ano Turma Aluno1 João 2134 EI 1 E Aluno2 Ana 2133 EI 1 A Aluno3 Pedro 2131 EI 1 A Aluno4 Isabel 2135 EI 1 A Método define uma funcionalidade das futuras instâncias de uma classe. São normalmente descritos recorrendo a verbos. Todos os objectos da mesma classe sabem executar o mesmo comportamento. Como? • Criar uma instância da classe Aluno . como faze-lo? Basta recorrer aos métodos existentes na classe. Sebenta da Disciplina de Introdução à Programação • Identidade (definida pela classe) e pelo nome de identificação do objecto.

Nome . E que desejamos consultar a turma de um aluno . No mundo que nos rodeia lidamos com vários grupos de pessoas.DSI A classe Professor tem os seguintes atributos • Nome • Numero de Identificação Fiscal • Departamento • Ordenado • Categoria Relembrando a classe Aluno : A classe Aluno tem os seguintes atributos • Nome • Numero • Ano • Turma • Curso • Valor da Propina • ValoPago de Propina Podem verificar que as duas classes possuem atributos com a mesma designação.Adjunto Departamento . Em programação. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 24 .231 Categoria . Esse método deve ser implementado na classe Aluno.Pedro Número . • Deve-se invocar um método que devolva a turma do aluno. por exemplo. ou seja. podemos criar também várias classes. Sebenta da Disciplina de Introdução à Programação • Deve-se invocar um método que devolva o número do aluno. Esse método deve ser implementado na classe Aluno. Isto acontece porque para caracterizar tanto o aluno como o professor precisamos de em ambos definir o atributo nome. Imaginemos o seguinte: No domínio Escola que outro conceito podemos encontrar ? O de Professor. várias classes que coexistem para algum fim. animais ou coisas.

A aplicação permite definir pontos cartesianos e linhas que se definem dando dois pontos. então qual (ou quais) as diferenças e relações entre estes dois conceitos? 2. Um utilizador para fazer a reserva de um livro tem que dar os seguintes dados: nome . Uma classe e um objecto são a mesma coisa? Se não são. Deverá ser possível consultar todos os automóveis existentes na empresa e verficar se um determinado está disponível ou não para aluguer. Identifique os métodos que cada uma das classes deve ter. a aplicação guarda a seguinte informação : Autor. Pretende-se desenvolver uma aplicação para desenho. No seu ponto de vista o que são atributos. numero do BI e morada. 2. Quais as classes que a aplicação deve conter? b.Exercícios Grupo I 1. Identifique os métodos que cada uma das classes deve ter. 3. Quais as classes que a aplicação deve conter? b. A aplicação permite consultar os livros que existem na biblioteca. o sistema regista este automóvel como ficando indisponível. a. Identifique os atributos de cada classe c. Quais as classes que a aplicação deve conter? b. titulo. Pretende-se desenvolver uma aplicação para gestão de uma biblioteca. Para cada livro. métodos e mensagens? Grupo II 1. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 25 .2 . assim como fazer reserva de livros. Identifique os atributos de cada classe c. Quando um automóvel é alugado. editora. Pretende-se desenvolver uma aplicação para gestão de um empresa de aluguer de automóveis. Identifique os métodos que cada uma das classes deve ter. a. a. 2. Sebenta da Disciplina de Introdução à Programação Aluno Professor Nome Nome Numero Numero de Identificação Ano Fiscal Turma Departamento Curso Ordenado Valor da Propina Categoria ValoPago de Propina Nota : Classes diferentes podem ter atributos com o mesmo nome. Identifique os atributos de cada classe c.

Identifique os métodos que cada uma das classes deve ter. a. Quais as classes que a aplicação deve conter? b. Sebenta da Disciplina de Introdução à Programação 4. Identifique os atributos de cada classe c. A aplicação deve permitir preencher um boletim realizar o sorteio da chave premiada e realizar a selecção dos boletins premiados. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 26 . Pretende-se desenvolver uma aplicação para jogar o totoloto.

é uma palavra reservada $dólar inválido. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 27 . constantes e outras entidades que este manipula). carácter acentuado no nome limite Inf inválido. pois facilitam a compreensão dos programas por programadores a elas habituados. A sua semântica não pode ser alterada pelo programador. isto é. designados por palavras reservadas. underscore ou cifrão) Não podem conter espaços! Contrariamente ao que acontece noutras linguagens.Palavras Reservadas Os identificadores podem ser escolhidos pelos programadores (ex: numeroDoAluno). é aconselhável a sua utilização. dígitos.2 . o Java distingue entre maiúsculas e minúsculas. devem ter nomes sugestivos de acordo com o propósito a que se destinam. Estas são palavras utilizadas na definição da linguagem e que têm um significado próprio nesse contexto. também se podem utilizar identificadores previamente definidos na linguagem. Também para o Java é comum usar convenções para os identificadores a criar quando se desenvolve um programa: • Os nomes das classes começam por letras maiúsculas (ex: Aluno) • Qualquer outro nome começa por letras minúsculas. começa por dígito X1 válido M&M inválido. carácter & é ilegal int inválido. Exemplo Quais dos seguintes identificadores são válidos em Java e quais não são? 1_x inválido.Identificadores Os identificadores são nomes atribuídos aos diferentes elementos de um programa (classes. espaço em branco 3. métodos. No entanto. os quais em java seguem as seguintes regras: Devem ser iniciados por uma letra. variáveis. objectos. por exemplo o de um método (ex: main()) • As palavras seguintes à primeira.1 . underscore (_) ou cifrão ($) Podem ter outros caracteres (letras. começam com maiúscula (ex: disciplinaDoCurso) • Os identificadores devem sugerir o seu valor semântico. Conceitos básicos de programação em Java 3. Sebenta da Disciplina de Introdução à Programação 3. ou seja: A ≠ a B ≠ b public static void ≠ PUBLIC STATIC VOID Ainda que as convenções não sejam obrigatórias e o compilador não verifique se são cumpridas.

Lista das principais palavras reservadas existentes na linguagem Java 3. Tal como as palavras reservadas.14159. os símbolos têm um significado bem definido e não podem ser utilizados para outro fim. Sebenta da Disciplina de Introdução à Programação abstract boolean break byte byvalue case cast catch char class const continue default do double else extends false final finally float for future generic goto if implements import inner instanceof int interface long native new null operator outer package private protected public rest return short static super switch synchronized this Throw throws transient true try var void volatile while * Figura 9. Como podemos verificar na figura seguinte. Os Valores são dados explícitos que podem ser manipulados pelo programa.3 . -0.4 . No entanto. isto é são todos os valores aceites pela linguagem. o armazenamento de um novo valor numa variável destrói o valor anterior dessa mesma variável. em cada momento uma variável pode apenas conter um valor. Por exemplo: Número inteiros: 65 e -301 Números reais: 3. (. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 28 . * e = Sinais de pontuação: {.02 e 5. -.88f Os caracteres: ‘a’.Variáveis Uma variável é uma localização em memória na qual podemos guardar um valor de um dado tipo.Símbolos e Valores Os Símbolos definidos em Java incluem diversos: Operadores: +. A cada variável estão associados um tipo e um nome. O valor de uma variável pode variar durante a execução do programa. }. ) e . ‘A’ e ‘\n’ Cadeias de caracteres: “Bom dia!” 3.

int ano.5 . char turma. String). 3. Para referenciar um atributo de um objecto devemos indicar o nome do objecto e o nome do atributo. Classes diferentes podem ter atributos com o mesmo nome. double valorPropina. • Tipos de dados que uma variável pode ter. Armazenam directamente os valores.1 os atributos definem as características das futuras instâncias de uma classe. mas são utilizados para guardar os endereços de memória onde se encontram estes dados. Representação gráfica do conceito de variável 3.1 . double. Exemplo: © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 29 . Ao definir uma classe em Java que represente as características de um aluno teremos os seguintes atributos: int numero.4. Sebenta da Disciplina de Introdução à Programação char turma = ‘A’ turma = ‘E’ turma -> endereço de memória 1002 turma -> endereço de memória 1002 A E Célula de Célula de memória memória 1002 1002 Figura 10. Têm um nome único dentro da mesma classe. Mais concretamente os atributos são variáveis que guardam os valores que caracterizam os objectos.Tipos de Dados Em Java temos dois grupos de tipos de dados: Tipos de Dados Primitivos: são utilizados para guardar números. double valorPago. Mas para cada característica teremos que indicar qual o tipo de dados a que pertence. String nome. caracteres e valores booleanos.Variáveis de Instância: Atributos Como vimos em 3. String curso. Para podermos definir atributos em Java precisamos de dominar os seguintes conceitos: • Como declarar uma variável. Tipos de Dados Referenciados: não guardam os dados directamente. • O que significam as palavras reservadas (char. int.

// a variável numero é do tipo primitivo String nome = new String (”Pedro”).Tipos de Dados Primitivos Por agora vamo-nos focar apenas nos tipos de dados primitivos. long • Dois representam números Reais: float. A linguagem Java coloca oito tipos de dados primitivos à nossa disposição: • Quatro representam inteiros: byte. int.5.1 . Figura 12. • A variável nome guarda o valor 40B40. Este valor representa a zona de memória onde está guardada a cadeia de caracteres “Pedro”.Representação gráfica da possível localização em memória das variáveis declaradas nos dois exemplos anteriores • A variável número guarda o valor 2133. Um tipo de dados é definido pela gama de valores que pode representar e pelas operações que sobre eles se podem efectuar. Por isso diz-se que a variável nome é uma referência. short. Sebenta da Disciplina de Introdução à Programação int numero = 2133. double • Um representa caracteres: char • Um representa valores Lógicos : boolean © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 30 . 3. // a variável nome é uma referencia memória numero 2133 20A20 nome 40B40 30A40 referência “Pedro” 40B40 Figura 11.

767 (16 bits) int 4 bytes −2. variável de cada um destes tipos.147. 5. -45.036.775. Sebenta da Disciplina de Introdução à Programação 3. Nesta tabela podemos ver o espaço ocupado por uma Figura 14. 12. bem como o maior e menor valor que essa variável pode ter. .768 32. tem um ponto decimal ou a notação exponencial.2 .6E27 Tipo Tamanho float 4 bytes (32 bits) double 8 bytes (64 bits) Figura 15.0.1.372.648 2.483. Diferentes tipos de inteiros oferecidos pela linguagem Java.147.807 (64 bits) Figura 13. tem um expoente (E) Ex: 5.0.40282346638528860e+38 double 4.036. 12.775.223.79769313486231570e+308 Figura 16.34.1 .854.8.372.5. 0. Reais Um número real pode ser representado usando a notação decimal.808 9.1. Maior e menor valor representáveis pelos diferentes tipos de dados reais do Java © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 31 . Inteiros Tipo Tama- Inteiro nho Menor Valor Maior Valor byte 1 byte −128 127 (8 bits) short 2 bytes −32.854.40129846432481707e-45 3. Tipos de dados reais existentes em Java Tipo Menor Valor Maior Valor float 1.5.223.647 (32 bits) long 8 bytes −9. Como exemplos de valores típicos a guardar em variáveis de cada um dos tipos inteiro podem ser apresentados: byte: 40 short: -22 500 int: 1 500 000 long: 4 000 000 000 3.94065645841246544e-324 1.483.

Declaração. 3. que. tipo de dado identificador da variável char turma Figura 17. Na realidade.4 . 3.5.1. as variáveis do tipo char armazenam números que identificam os caracteres de acordo com um código denominado UNICODE. Os valores do tipo char são delimitados por plicas( ' ): Exemplos: // 'a' 'X' '7' '$' '. Inicialização 3. Esquema representativo da declaração de variáveis A declaração reserva um espaço em memória necessário para guardar o tipo de valor © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 32 .1. evidentemente.5. a especificação do seu nome (identificador) e da gama de valores que pode conter (tipo de dados). Sebenta da Disciplina de Introdução à Programação 3. Caracteres O armazenamento de caracteres em Java é conseguido pelo tipo char. Utilização Para usar uma variável é necessário fazer a sua declaração previamente.). Lógico O armazenamento de valores lógicos em Java é conseguido pelo tipo boolean.' '\n' // são valores do tipo char char letra = 'a‘. Declaração 2. As palavras reservadas true e false são os únicos valores válidos para um tipo Lógico Exemplo: boolean terminado = false.5. Inicialização e Utilização Quando trabalhamos com uma variável destinguimos 3 etapas: 1. Este é o símbolo que se usa em Java para indicar o final de qualquer declaração ou instrução. apenas pode assumir um de dois valores: verdadeiro.3 . Este código é um standard internacional de representação de caracteres que contém símbolos e caracteres dos alfabetos ocidentais e orientais. ou falso.1. isto é.5 . A declaração é terminada com um ponto e vírgula (.

(este comando será explicado em 3. Sebenta da Disciplina de Introdução à Programação A inicialização consiste na atribuição de um valor a uma variável: numero = 2133. // a variável nome é uma referencia do tipo String Definição:A variável do tipo referenciado é chamada referência. //inicialização resultado = numero + 100.2 . Uma referência é uma variável que guarda o endereço do local onde se encontra um objecto de uma dada classe. na maioria dos casos. int numero.) © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 33 . Podemos. mas sim do valor inicial da variável. declarar e inicializar uma variável na mesma expressão. É na inicialização que a variável fica com um valor definido. deve ser executado o comando new seguido de nome da classe utilizada na declaração dessa variável.1 . Para declarar uma variável do tipo referenciado deve se indicar o nome da variável e o nome da classe. String nome. que estudamos mais tarde). turma = ‘A’. Exemplo: int sum = 0. Para atribuir valor a uma referencia.7. Quando uma variável é referenciada num programa. // declaração numero = 213. é utilizado o valor actual (ver código abaixo). Assim os tipos de dados referenciados são classes (e arrays.5. É de notar que a declaração de uma variável apenas provoca a reserva de espaço de memória necessário e a sua identificação pelo nome declarado e não define um valor. no entanto. int base = 32. podendo a partir de agora ser utilizada. resultado. no sentido que definam a possível gama de valores e operações que podem ser efectuadas com estes valores. //utilização do número // e inicialização do resultado 3. max = 149. que é guardado no espaço reservado. Não estamos a falar de um valor qualquer.Tipos de Dados Referenciados As classes são novos tipos de dados.

String nome = “Rita”. isto é. O Java tem um conjunto de classes já elaboradas que permite aceder a um conjunto de funcionalidades e propriedades já definidas. Cada instância da classe String é uma cadeia de caracteres. frase “Introdução à Programação” nome “Rita” “Pedro” Para além de referenciar os objectos das classes já existentes em Java. nome = new String(“Pedro”). qualquer operação sobre uma String devolve uma nova String (String modificada) String frase = “Introdução à Programação”. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 34 . Enquanto essa variével não está inicializada. uma vez que seja atribuido um valor a uma String este não pode ser alterado. A inicialização pode ser efectuada pela instrução: nome = “Rita”. Uma String serve para guardar valores constantes. nome = “Pedro”. Sebenta da Disciplina de Introdução à Programação String nome. Uma destas classes é a classe String que já foi referida aquando da definição dos atributos nome e curso da classe Aluno. como veremos mais à frente. Quando é declarada uma variável do tipo String ( String nome) é reservado um espaço em memória para guardar um endereço da futura cadeia de caracteres. pode-se referenciar também os objectos de classes por nós criadas. É uma classe bastante utilizada e que serve para manipular cadeias de caracteres. Assim. o valor da variável nome é NULL ( isto é a referência não tem valor) .

A expressão da direita é calculada em primeiro lugar. sum Å 25 conta = sum + 15. Diferentes representações para os operadores de atribuição Ao símbolo = chama-se operador de atribuição.1 . Os operadores de atribuição Java simplificam essas operações.6. A instrução de atribuição permite armazenar um valor numa variável. conta Å 25 sum = conta.2 .Operadores e Expressões 3. e em seguida armazenar-se o valor obtido nessa mesma variável.Operadores Aritméticos Operadores que podem ser utilizados sobre valores de tipo inteiro: © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 35 . é equivalente a num = num + conta.Operadores de Atribuição Por vezes é necessário efectuar uma operação sobre uma variável. A instrução num += conta.6 . pode estar no lado esquerdo e direito da instrução de atribuição.6. conta Å 40 conta = conta + 1. Só pode ser atribuído um valor a uma variável que seja consistente com o tipo de dados declarado para essa variável. Operador Exemplo Equivalente a += x += y x=x+y -= x -= y x=x-y *= x *= y x=x*y /= x /= y x=x/y %= x %= y x=x%y Figura 18. A mesma variável. conta Å 41 3. conta = 25. Considere-se o exemplo: int conta . Sebenta da Disciplina de Introdução à Programação 3. sendo o resultado armazenado na variável da esquerda. o sinal = deve ler-se “toma o valor de”. Neste contexto.

As interpretações possíveis são: 30 + 10 e 10 = 20 30 + = 35 2 2 errado! correcto! Grau de Operação Precedência Alto () Médio -. % Baixo +.1 25 Multiplicação * 26 * 10 260 Divisão / 26 / 10 2 Módulo % 26 % 10 6 (resto) Figura 19. Figura 21. Interpretações possíveis da ordem dos operadores e tabela com as regras de precedência correctas . Conjunto de operações que podem ser efectuadas sobre valores do tipo inteiro A precedência de operadores determina a ordem de execução das operações. Sebenta da Disciplina de Introdução à Programação Operação Símbolo Exemplo Resultado Adição + 26 + 10 36 Subtracção . Operadores que podem ser utilizados sobre valores de tipo inteiro: © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 36 . - Figura 20. 26 . + (unários) *. /.out.println(30 + 10 / 2). Por exemplo considere-se a instrução: System.

© Escola Superior de Tecnologia de Setúbal 2005-2006 Página 37 .4 / 2.6.4 Multiplicação * 5. Precedências dos operadores sobre números reais Figura 24. 5.0 2. enquanto que o AND e o OR são operadores binários (têm dois operandos) A b a && b a || b a ! a true true true true true false true false false true true false false true false true false true false false false false false true Figura 25. O NOT é um operador unário (tem apenas um operando). Operações possíveis sobre reais Grau de Operação Precedência Alto () Médio -.0 10.3 .2. || e ! Figura 27. / Baixo +.Operadores Lógicos As expressões lógicas podem utilizar os seguintes operadores lógicos: ! NOT && AND || OR Operam sobre operandos lógicos e produzem resultados lógicos.4 * 2. Tabelas de verdade dos operadores &&.7 Figura 22. - Figura 23. Sebenta da Disciplina de Introdução à Programação Operação Símbolo Exemplo Resultado Adição + 5.0 7.4 + 2.0 3. 3.8 Divisão / 5.4 .4 Subtracção . + (unários) *. Figura 26.

Sebenta da Disciplina de Introdução à Programação 3.7 double 2*((20/6)+(3*(2-1.5) 1. x fica false 8-1 != 3 + 4 false ‘a’ < ‘b’ || ‘c’ < ‘a’ true (!a && b)|| (a || !b) true para a=true e b=false © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 38 .4 .5+6%4*2.Operadores Relacionais Relacionam duas expressões de um mesmo tipo de dados e retornam um valor de tipo boolean: Operador Designação > Maior que >= Maior ou igual a < Menor que <= Menor ou igual a == Igual a != Diferente de 3.1 6. As expressões podem ser calculadas.6.5 . obtendo-se um novo valor.6.5+1-1. indicando também o tipo do valor obtido Expressão Resultado 3-4*2+1 -4 int 2*(12%5)-(8-3)/2 2 int 2*12%5-8-3/2 -5 int 2.5)))% (2.Expressões Uma expressão é uma sequência de operadores e de valores.0 double Exemplo 2: Determine o resultado das seguintes expressões ou instruções Expressão Resultado 3+5/2) >= (1-4%2) true x=3 == 4. Podemos ter: Expressões Aritméticas – envolvem operadores aritméticos 5 * ( 2 + 3 ) + ( 7 – 3 ) / 2 Resultado: 27 As expressões aritméticas são calculadas levando em conta a prioridade dos diferentes operadores envolvidos Expressões Lógicas – têm como resultado um valor lógico e são construídas com operadores relacionais e operadores lógicos Exemplos: Exemplo1: Determine o valor das seguintes expressões.

Exemplo: • O aluno para pagar uma prestação da propina precisa de indicar o valor que vai pagar. em Java. ao passo que os nomes de objectos começam com minúsculas (ex: nomeObjecto). por indicarem algum tipo de acção e permitem modificar ou interrogar os objectos relativamente ao seu estado actual. Essa informação é passada através dos parâmetros. Através da instrução return é determinada qual o valor que o método devolve return <expressão>. • O aluno para mudar de turma precisa de indicar qual a nova turma.7 . a qual é constituída por: • Tipo de retorno • Nome • Número e tipo de parâmetros O formato geral de um método é o seguinte: tipoRetorno nomeMetodo(listaParametros) { declaracoes.Métodos Definem funcionalidade das futuras instâncias de uma classe. } Nota: Por convenção. Não é possível na mesma classe a existência de métodos com a mesma assinatura. Os nomes dos métodos começam também por minúsculas (ex: nomeMetodo). os nomes de classes começam por letras maiúsculas (ex: NomeClasse). O objecto para executar uma determinada operação pode precisar de dados. Parâmetros São variáveis que referenciam diferentes tipos de dados dos quais o método necessita para levar a cabo a sua tarefa. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 39 . São normalmente descritos recorrendo a verbos. instruções. Os parâmetros são os dados de entrada . Um método tem sempre uma assinatura. Nota : Dois métodos têm a mesma assinatura quando o nome. Sebenta da Disciplina de Introdução à Programação 3. o valor de retorno e a lista de parametros são idênticos em ambos. return (se for o caso).

• Tem o mesmo nome da classe. ou seja. segundo = 0. Podem existir construtores com parâmetros e construtores sem parâmetros. equivalente a: <nome da classe>() { //……. public Relógio() { hora = 24. a máquina virtual encarrega-se de criar um em tempo de execução. char) • false se o atributo for de tipo boolean © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 40 . } De acordo com as regras de criação de um construtor: class Relogio { private int hora. long. segundo. double.1 . O seu único e exclusivo objectivo é inicializar os atributos. Vejamos o seguinte exemplo: class Relogio { private int hora. segundo. } } Quando não se define nenhum construtor na classe que especifica o objecto. Sebenta da Disciplina de Introdução à Programação 3. } Este construtor inicializa os atributos do objecto com valores default. • Não possui retorno. Neste sub-capítulo apenas nos vamos debruçar sobre os construtores sem parâmetros. minutos. dar um estado inicial ao objecto. Regras na construção de um construtor: • É sempre de acesso publico. byte.Método construtor sem argumentos Uma das partes mais importantes da programação orientada por objectos é saber utilizar correctamente os construtores de objectos. minutos = 0.7.float. minutos. O construtor é um método especial utilizado apenas na criação e inicialização de objectos de uma determinada classe. int. que correspondem a: • 0 se o atributo for de tipo numérico (short.

out.Invocação de métodos e passagem de parâmetros A invocação de um método deve obedecer à seguinte regra: nome_objecto. 0 e 0. Para o exemplo anterior da classe Relogio teriamos: Relogio rel = new Relogio( ).nome_método(<lista de Parâmetros>) Vejamos um exemplo: class Teste { public void metodoOla () { System. Para criar uma instância de uma classe utilizamos o operador new. caracterizados por três atributos: hora. cujos valores respectivamente são.7.//invocação do método } } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 41 . Sebenta da Disciplina de Introdução à Programação • null para referências Nota: null representa uma referência nula. Poderão estes dois objectos existir ao mesmo tempo ? SIM!!! 3. Teríamos um objecto denominado rel e outro denominado despertador. obj. 24. Relogio despertador = new Relogio ( ). minuto e segundo. para um objecto pertencente a uma qualquer classe. que quando é executado aloca a memória necessária para guardar o objecto em causa na memória.metodoOla(). Instanciação é o processo de criar instâncias (objectos) de uma determinada classe.println(“ola”). new <nome da classe> (<lista de parâmetros actuais>).2 . É uma operação feita sobre a classe e não sobre os objectos (dado que os objectos já são instâncias não faz sentido criar instâncias a partir deles). não existente. } } class Programa { public static void main(String args[]) { Teste obj = new Teste().

Sebenta da Disciplina de Introdução à Programação Como foi possível ver o objecto obj invocou um método da sua classe.println("Sou o construtor por default da PrimeiraClasse").out.out. Porquê? Porque o método metodoPrimeiraClasse() não faz parte da classe SegundaClasse. } } public class SegundaClasse { public SegundaClasse() { System. Importante: Todo o objecto só pode invocar métodos da sua classe. } public void metodoPrimeiraClasse() { System. } } Ao analisarmos o código verificamos que a instrução segunda. tal como podemos ver no exemplo seguinte: © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 42 .out.println("Sou o metodoSegundaClasse"). segunda.println("Sou o construtor por default da SegundaClasse"). Será possível um objecto invocar um método de outra classe ? Veja-se o próximo exemplo: public class PrimeiraClasse { public PrimeiraClasse() { System.metodoPrimeiraClasse( ) não está correcta. segunda.metodoPrimeiraClasse().out. } } public class Principal { public static void main(String[] args) { SegundaClasse segunda = new SegundaClasse().println("Sou o metodoPrimeiraClasse").metodoSegundaClasse(). } public void metodoSegundaClasse() { System.

Teste obj = new Teste(). o comportamento é diferente. A lista de parâmetros formais e actuais deve ter correspondência. obj. Estes dados são chamados parâmetros actuais.passagem(variavel). Cada parâmetro de lista de parâmetros actuais deve corresponder. 14 System.passagem(variavel). 7 7 var = var * 2 . Na passagem de tipos referenciados. a passagem de parâmetros é sempre feita por valor. Consideremos o seguinte código: class Teste { public void passagem ( int var) { var = var * 2 . } } O código apresentado ilusta a invocação de um método por parte de um objecto da classe Teste e a passagem de parâmetros por valor. quando se está a lidar com variáveis do tipo referenciado.println(variavel). No quadro seguinte podemos seguir o conteúdo das variáveis definidas no programa anterior : Variáveis Linha de código variavel var int variável = 7. --------. System. O parametro formal é var e parametro actual é variável.out.out. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 43 . pelo tipo e pela sua posição na lista. Sebenta da Disciplina de Introdução à Programação Passar parâmetros a um método significa chamar esse método dando-lhe como entrada os dados que ele necessita.println(variável). Em Java. } } class Programa { public static void main(String args[]) { int variavel = 7. 7 --------- Obj. Este ponto será explicado detalhadamente no capitulo 4 – Tópicos Avançados de POO. 7 --------- No exemplo acima as variáveis que estavam envolvidas na passagem de parâmetros (variável e var) eram variáveis do tipo primitivo int. Na chamada é efectuada a ligação entre parâmetros formais (definidos no cabeçalho do método) e parâmetros actuais. a um parâmetro formal definido no cabeçalho do método.

Vejamos o próximo exemplo: class Calculo { public int somaValores() { int valorA = 10. pois devemos sempre garantir a correspondência dos tipos. Sebenta da Disciplina de Introdução à Programação Para terminarmos este capítulo. a instrução return não é especificada e no cabeçalho do método no lugar do tipoRetorno deve se indicar void.somaValores().somaValores(). } } class Programa { public static void main(String args[]) { Calculo resultado = new Calculo(). tipoRetorno nomeMetodo(listaParametros) { declaracoes.out. } Se o método não devolve valor. int resultado = valorA+valorB. return (se for o caso). No início do capítulo foi dito que através da instrução return é determinada qual o valor que o método devolve. } } O método somaValores é um método que retorna o valor que foi atribuído à variável resultado.println(valorRetornado). instruções. Ao analisarmos o método main podemos ver a seguinte instrução valorRetornado = resultado. System. valorB = 2. Isto é muito importante. return resultado. int valorRetornado = resultado. iremos ver o retorno dos métodos. Que valor guardará a variável valorRetornado ? 12 Reparem que tipo da variável valorRetornado é igual ao tipo da variável resultado. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 44 .

int an.”EI”.println(valorRetornado). 1. ‘A’).out. int valorB) { int resultado = valorA+valorB. ‘A’).3 .somaValores(2. serve como apontador para o // endereço de memória que o objecto irá ocupar.7. 2133. qual o seu valor ? 15 • E qual será o valor de x depois de ser utilizado como parâmetro ? 10. int valorRetornado = resultado. int x = 10. 1. // A variável aluno1 é uma referência a um objecto. String curs. na verdade. Aluno aluno2 = new Aluno(“João”. 2134. y = 5. // A variável. System.Métodos construtores com argumentos É possível agora avançar para a criação de objectos utilizando construtores com uma lista de parâmetros. return resultado. valorRetornado = resultado. qual o seu valor ? 7 • Da segunda vez que a variável valorRetornado guarda o valor retornado. int num.println(valorRetornado). No exemplo da classe aluno podemos encontrar um: public Aluno(String nom.5).out.y). System. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 45 . mas com passagem de parâmetros: class Calculo { public int somaValores(int valorA. } } • Da primeira vez que a variável valorRetornado guarda o valor retornado.somaValores(x. char turm) {…} Seguindo a regra de criação de objectos teremos então: Aluno aluno1 = new Aluno(“Pedro”. Sebenta da Disciplina de Introdução à Programação O seguinte exemplo é idêntico ao anterior. 3.”EI”. } } class Programa { public static void main(String args[]) { Calculo resultado = new Calculo().

Aluno aluno3 = new Aluno(“Ana”. 2133. 2131. private double valorPago. Sebenta da Disciplina de Introdução à Programação Aluno aluno3 = new Aluno(“Ana”. . Aluno aluno5 = new Aluno(“Rita”. char turm) { nome = nom. na qual está definido o main: class Programa { public static void main(String args[]) { Aluno aluno2 = new Aluno(“João”. será apresentado o código da classe Aluno referente à definição de atributos e definição do construtor: public class Aluno { //ATRIBUTOS private String nome. private int numero. //CONSTRUTORES public Aluno(String nom. int num. valorPago=0. numero = num.”EI”. ano = an. curso =curs. String curs.”EI”.”EM”.. int an. ‘A’). private double valorPropina. 1. private char turma. 2137. } } A criação de objectos neste exemplo. private int ano. private String curso. Em seguida para consolidar os conhecimentos até aqui adquiridos. ‘A’).. 1. 1. ‘A’).”EI”. ‘A’). turma = turm. valorPropina = 0. 2131. será criada numa outra classe. } } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 46 . 1.

Contudo o valor atribuído pode resultar do cálculo de uma expressão. encontramos as seguintes instruções: valorPropina=0. No caso das variáveis valorPropina e ValorPago o valor é fornecido directamente.devolve o valor da propina paga • getValorPago( ) – devolve o valor já pago da propina © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 47 . tal como: class Programa { public static void main(String args[]) { int ano = 2005. valorPago=0. } O método getNumero( ) • devolve o valor da variável numero • o nome do método é getNumero • o tipo de retorno é do tipo inteiro (Como numero é uma variável do tipo inteiro o tipo de retorno também é do tipo inteiro) A seguir apresentam-se os restantes métodos selectores do nosso exemplo da classe Aluno • getNome( ) – devolve o nome do aluno • getCurso ( ) – devolve o curso em que o aluno esta inscrito • getTurma ( )– devolve a turma em que o aluno esta inscrito • get Ano( ) – devolve o ano em que o aluno esta inscrito • getPropina (). int anoNascimento = 1971 int idade = ano .4 . public int getNumero() { return numero.Métodos selectores Os métodos selectores são aqueles que devolvem o valor de um atributo da classe.7. Sebenta da Disciplina de Introdução à Programação No método construtor da classe Aluno.anoNascimento } } 3.

‘A’). } public double getPropina() { return valorPropina.getNumero( ). 2133.getNumero( ). Trata-se de um método que devolve um valor.Métodos modificadores Chamam-se métodos modificadores aqueles que servem para alterar/modificar o valor de um atributo.5 . } public String getCurso() { return curso. Estará correcto? Não. } public int getAno() { return ano. public void setTurma(char novaTurma) { turma=turm. 3. } public double getValorPago() { return valorPago. int numero = aluno2. Sebenta da Disciplina de Introdução à Programação public String getNome() { return nome. logo devemos recebe-lo de alguma forma. } public char getTurma() { return turma. (quando um aluno muda de turma o valor tem que se alterar) © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 48 . } O método void setTurma(char novaTurma) • Modifica o valor do atributo turma. } Utilizando um objecto da classe Aluno Aluno aluno2 = new Aluno(“João”.”EI”.7. 1. reparem: aluno2. • Como consultar o número deste aluno ? Pode-se utilizar um método selector.

Ao invocar o método modificador setCurso os atributos deste objecto ficaram: Classe Aluno Atributos Objecto Nome Número Curso Turma Aluno1 João 2133 EA A 3.8 . ‘A’). 1. uma aplicação informática é constituída por um programa principal onde é iniciada a aplicação e quando é executadaa última linha do programa principal a aplicação termina. o Um método principal chamado main(). Sebenta da Disciplina de Introdução à Programação • nome do método é setTurma • o tipo de retorno é do tipo void –não retorna valor nenhum • Recebe como parâmetro o valor para a nova turma.8. seja em Java seja noutras linguagens.”EI”. Este utiliza então métodos que podem existir na mesma classe ou noutras. uma aplicação é constituída por uma ou mais classes. Em Java. 2133. Classe Aluno Atributos Objecto Nome Número Curso Turma Aluno1 João 2134 EI A aluno2. utilizando a classe aluno Aluno aluno2 = new Aluno(“João”. que é do tipo String Exemplo. } O método void setCurso(String novoCurso) • Modifica o valor do atributo curso ( quando um aluno muda de curso o valor tem que se alterar) • nome do método é setCurso • o tipo de retorno é do tipo void –não retorna valor nenhum • Recebe como parâmetro o valor para o novo curso. que é do tipo carácter (char) public void setCurso(String novoCurso) { curso=novoCurso. o Um conjunto de métodos definidos pelo programador. • Os métodos contêm: o Declarações de variáveis.Estrutura do programa principal Regra geral.1 . Uma (e só uma) dessas classes contém um método chamado main que é o programa principal. o Instruções.setCurso(“EA”).Estrutura de Aplicações em JAVA 3. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 49 . Existem três regras importantes na estruturação de um programa (livro FCA – Fundamentos de Programação em Java2): • Um programa contém: o Declarações de variáveis.

Uma variável global é aquela que é declarada no início do programa e subsiste até que o programa termine.. public static void mudaValor2(int v2) { // novoValor é uma variável local ao método int novoValor = v2 + valor2. pois existem em subprogramas distintos. Sebenta da Disciplina de Introdução à Programação o Chamadas a outros métodos (predefinidos ou criados pelo programador). © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 50 . // variável global public static int valor2 = 10. valor2 = novoValor.3 . Podemos então classificar as variáveis da seguinte forma: • Variáveis locais • Variáveis globais Uma variável declarada dentro de um subprograma é chamada de variável local a esse subprograma. estamos a falar de variáveis diferentes. } . Para mostrar informação ao utilizador temos que ser capazes de escrever para o ecran. Uma variável local é criada sempre que o subprograma é activado e destruída quando este termina a sua execução. System.Entrada e Saída de Dados A interacção da aplicação com o utilizador é efectuada através de entrada e saída de dados. sendo visível dentro de qualquer subprograma que o constitui. Os detalhes de implementação de um método são irrelevantes. Ainda que haja outro subprograma que contenha uma variável declarada com o mesmo nome.println(“Valor2 depois da chamada = ” + valor2). class VisibilidadeVariaveis { private int valor1. Para além de serem visíveis dentro de qualquer subprograma que constitui a aplicação.out. desde que se saiba para que é que ele serve. que parâmetros recebe e que tipo de resultado deve produzir (é como se fosse uma caixa negra!). 3. as variáveis globais podem também ser utilizadas por esses subprogramas.2 .println(“Valor2 antes da chamada = ” + valor2).8. por períodos de tempo diferentes e visibilidades diferentes.out.. Não é no entanto aconselhado o uso abusivo deste tipo de variáveis dadas as limitações que causam na legibilidade do código e a facilidade com que provocam o aparecimento de erros difíceis de detectar. Para pedirmos informação ao utilizador temos que ser capazes de ler do teclado. mudaValor2(33). Para além disso não contribuem em nada para a reutilização de código pois tornam o código desenvolvido dependente do contexto de utilização. que existem em espaços de memória separados.8. public static void main(String args[]) { // Resultado = 43! System. } } 3.Visibilidade das Variáveis Visibilidade de uma variável é uma noção associada ao local onde a variável é declarada no programa.

. quando queremos escrever para o ecran utilizamos a instrução em Java System. 2131. Voltando ao nosso exemplo do Aluno. aluno3. 1. Sim. 1. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 51 .out.) devem ser pedidos ao utilizador.println(“Turma” + t). então a classe que instancia tem que ter definido o método toString(). System. A escrita de informação para o ecran designa-se por saída de dados. para este exemplo ser interactivo. 2133.setTurma(‘E’). char t= aluno3. a variável i e a variável t são do tipo de dados primitivo.println( x). return str. os dados sobre o aluno (nome. numero etc.getNumero(). // Onde x é a variável que se pretende mostrar no ecran. System. Será que é possível escrever a seguinte instrução? System.”EI”. public String toString() { String str= "Nome:" + nome + "Numero :" + numero + " curso : " + curso + " ano" + ano.out. } } No exemplo de código apresentado. mas para essa instrução imprimir informação sobre o objecto aluno3.out. Aluno aluno3 = new Aluno(“Ana”. Sebenta da Disciplina de Introdução à Programação class Programa { public static void main(String args[]) { Aluno aluno2 = new Aluno(“João”. ‘A’).getTurma(). ou se x é de um tipo referenciado.println(aluno3). int i= aluno3. A entrada de dados para o programa é feita através da leitura de dados do teclado. Como já temos visto ao longo dos exemplos anteriores.”EI”. é necessário definir na classe Aluno o método toString().out.println(“Numero” + i). ‘A’). Nota: x pode ser uma variável de um tipo de dados primitivo. }.

in que esta associado ao teclado Scanner sc = new Scanner(System.setTurma(‘E’). 1. System.”EI”. int num = scanTeclado.”EI”. Aluno aluno3 = new Aluno(“Ana”. Exemplo import java.in).out.out. 2131. int i= aluno3. Sebenta da Disciplina de Introdução à Programação Voltando ao nosso exemplo da classe Aluno… class Programa { public static void main(String args[]) { Aluno aluno2 = new Aluno(“João”.0. 2133.in). introduzida com a versão J2SE 5. Para ler de forma confortável texto do canal de entrada padrão. } } A classe Scanner. Para cada um dos tipos primitivos há um método correspondente com a assinatura nextXxx() que retorne um valor desse tipo. System. ‘A’). class ExScanner { public static void main(String[] args)throws InputMismatchException { Scanner scanTeclado = new Scanner(System.getNumero().out. 1. } Tipo de dados metodo int nextInt() char nextChar() double nextDouble() float nextFloat() String next() Exemplo com a classe Aluno © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 52 .println(aluno3).nextInt(). aluno3. é uma classe que permite converter o texto para tipos primitivos.util.*. System.println ("Introduza um inteiro").println ("Numero introduzido:" + num). ‘A’). é preciso criar primeiro um Scanner sobre canal System.

nextChar ().nextInt().in). Sebenta da Disciplina de Introdução à Programação class Programa { public static void main(String[] args)throws InputMismatchException { Scanner scanTeclado = new Scanner(System.out. int ano = scanTeclado. System... modificadores e outros) public class <nome da classe> { //definição dos atributos de Instância <tipo1> <atributo1>.nextInt (). Para se definir uma classe deve obedecer-se à seguinte estrutura: • Definir atributos (variáveis) de instância • Definir construtores • Definir métodos (métodos selectores.out.out. Aluno aluno = new Aluno(nome.next ().. int num = scanTeclado. ano.. } } 3. // definição dos construtores <construtores> .Definição de Novas Classes Para além de utilizar as classes pré-definidas pela linguagem.println ("Introduza a turma de inscrição "). <atributo3>. <tipo2> <atributo2>.curso.. System.} void <método2>(<parâmetros>){.out. // definição dos métodos de instância void <método1>(){. int curso = scanTeclado. System. System.println ("Introduza o nome do Aluno "). char turma = scanTeclado.out. Sumariando os passos que tem sido dados para a construção da classe exemplificativa Aluno. é isso que temos vindo a fazer em muitos dos exemplos. int nome = scanTeclado.} <tipo> <método3>(){. por exemplo. System. não faz parte da linguagem).println ("Introduza o numero do Aluno ")... num.. A classe Aluno.} <tipo> <método4>(<parâmetros>){..4 ..} } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 53 . turma). é normal que seja necessário definir novas classes que nos ajudem a resolver os nossos problemas (aliás.next ().println ("Introduza o curso do Aluno ").println ("Introduza o ano de inscrição").8.

4). 3. este package é importado automaticamente sem necessidade de inclusão específica no programa. palavra=“Hoje ” String novaPalavra = frase.1 .5.4).8.Utilização de classes existentes em JAVA. Dos quais destacamos os seguintes: Método Descrição String() Cria um objecto do tipo String char charAt(int index) Devolve o caracter da posição index da string int compareTo(String anotherString) Compara duas Strings int indexOf(String str) Determina a localização da primeira ocorrência de uma cadeia de caracteres dentro de uma cadeia de caracteres String toUpperCase() Transforma em maiúsculas a cadeia de caracteres int lenght() Retorna o comprimento da string Nota: Para mais informações sobre os métodos disponibilizados pela String consultar a documentação do Java.8. int tamanho = frase.lenght().5. Para podermos utilizar num programa uma dessas classes é necessário importa-las. indice=7 String outraPalavra = frase. Sebenta da Disciplina de Introdução à Programação 3. 3. frase = “Hoje é quinta feira”.2 . outraPalavra=“quinta ” String outra = outraPalavra. novaPalavra=“hoje ” char c = palavra. tamanho=19 String palavra = frase. c=‘j’ boolean b = novaPalavra. A instrução em Java é: import <nome_do_pacote.) © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 54 .equals(“Hoje”).trim(). outra=“quinta” A classe String pertence ao package java. Estas classes estão guardadas em pastas compactadas.indice+7). b=false int indice = frase.lang .indexOf(“qui”).nome_da_classe> Vamos como exemplos analisar as classes String. disponibiliza vários métodos para manipular cadeias de caracteres.sqrt() – calcula a raíz quadrada. Exemplo de utilização dos métodos da classe String Codigo resultado String frase = “Hoje é quinta feira”.charAt(2). Math.substring(0. Classe String A classe String que já foi utilizada para definir os atributos da classe Aluno. Como já foi referido anteriormente o Java tem um conjunto de classes já elaboradas que permite aceder a um conjunto de funcionalidades e propriedades já definidas.sin() – calcula o seno de um ângulo.5 .8. Math e Random . Classe Math Uma classe das classes previamente elaboradas é a classe Math que inclui um vasto número de subprogramas que implementam diversas funções matemáticas (ex: Math.substring(indice. etc.toLowerCase(0.

Quando é necessário utilizar uma classe de um package mas não queremos usar a directiva import.out.0 e 1.0 public class Calculo { public static void main (String args[]){ int base=2.out.println(“O resultado é: ”+resultado).3 . Classe Random A classe Random é parte do package java. Alguns métodos da classe Random Método Descrição Random() Cria gerador de números aleatórios int next(int bits) Gera o número aleatório seguinte int nextInt() Retorna um número inteiro aleatório int nextInt(int n) Retorna um número inteiro aleatório de um intervalo de 0 a n double nextDouble() Retorna um número real aleatório. resultado = Math. int resultado = r.util. System.Random(). expoente=8. Sebenta da Disciplina de Introdução à Programação A classe Math pertence ao package java. System. java. expoente).5.util (fornece métodos para gerar números aleatórios). pode ser utilizado o seu nome completo. public class Calculo { public static void main (String args[]){ int base=2.8. Como não é uma classe do package java. } } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 55 .Random r = new java. Exemplo: Calcular a potência de um número elevado a outro.Random. este package é importado automaticamente sem necessidade de inclusão específica no programa. Para utilizar classes de outros pacotes é necessário importar (import) explicitamente a classe.nextInt().util. } } 3.lang é necessário importar explicitamente: import java. entre 0.pow(base.println(“O resultado é: ”+resultado). int resultado.util. expoente=8.lang .

} } 3. Sebenta da Disciplina de Introdução à Programação A desvantagem é que o nome que temos a escrever se torna demasiado extenso. linhas em branco e tabulação são genericamente designados por espaços em branco.out.out.util. Todos os espaços em branco adicionais são ignorados. para assegurar a legibilidade dos programas Exemplo de um programa Java com paragrafação package meuteste.nextInt(). Não influenciam o funcionamento do programa pois são ignorados pelo compilador. Os comentários em Java têm dois formatos: // formato utilizado para comentários no final da linha /* formato para comentários que se estendem por mais de uma linha */ 3. Deve ser utilizada a paragrafação. public class OlaMundo { public static void main(String[] args) { System.8.Comentários Os comentários de um programa documentam as instruções existentes.7 . pelo que nem sempre compensa utilizar esta abordagem. consiste em utilizar de forma explícita a directiva import: import java. System. public class Calculo { public static void main (String args[]){ Random r = new Random().8. int resultado = r.6 . Os espaços em branco são utilizados para separar identificadores e símbolos no programa. } } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 56 .println(“O resultado é: ”+resultado). Um programa Java pode ser formatado de múltiplas formas.println("Olá Mundo!").Random. Devem ser incluídos de forma explicar o propósito do programa e descrever passos do processamento. A outra abordagem possível.Paragrafação / Indentação Caracteres de espaço.

os métodos selectores e modificadores. b. Verificar se duas moedas são iguais. } } O Compilador ignora a paragrafação e os fins de linha. Implemente os métodos i. Implemente o método construtor b. Defina dois novos atributos relacionados com as notas de entrada para a escola. Adicionar moeda c.out. dólar. deverá ser implementado em Java. b. e. Implemente o método que gera os 6 números da chave do totoloto. deverá ser implementado em Java.Exercícios Práticos Objectivos da Série: Com esta série de problemas pretende-se que o aluno: Conheça as bases da programação orientada pelos objectos Saiba criar novas classes e instanciá-las 1. Sebenta da Disciplina de Introdução à Programação Exemplo de um programa Java sem paragrafação package meuteste. Implemente na classe programa a criação de um novo aluno com os seguintes dados Objecto Nome Número Curso Turma Especifica 12º ano de Mat aluno6 Joana 2155 EM B 13.println("Olá Mundo!").2 e. d. b. Implemente os métodos para visualizar as coordenadas do Ponto c. Implemente na classe programa a criação de um novo aluno com dados pedidos ao utilizador. Devera utilizar a classe Random. 4. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 57 .grupo2-ex4. a. 3. 2. 5. O resultado do exercício capitulo 2 .. a. f. O resultado do exercício do capitulo 2 . 3. Deverá pedir ao utilizador a nova turma. Franco suisso). Defina as classes com os atributos e métodos identificados. Implemente a classe Moeda que tem como atributos o valor monetário da moeda e tipo deMoeda (ex. Relativamente à classe Aluno do exemplo deste capítulo implemente em Java as seguintes alterações a. Implemente um método que faça uma translação horizontal do ponto. através do uso implícito do método toString. public class OlaMundo { public static void main(String[] args) { System.grupo2-ex1. Implemente a classe programa onde testa o construtor e os métodos anteriormente implementados. Implemente um método que retorne a media aritmética entre a nota da prova específica e a nota do 12º ano d. b. Implemente a classe programa onde testa o construtor. a. Defina a classe com os atributos e métodos identificados. Implemente o método construtor para inicializar o ponto. Implemente a classe programa onde testa o construtor. euro. Implemente na classe programa a funcionalidade da mudança de turma. a. Defina um novo construtor para a classe aluno que também inicialize estes dois novos atributos c. Implemente um método que faça uma translação vertical do ponto. E no final imprimir os novos dados do aluno.1 11. Implemente um método que calcule o ponto médio linha. Nota da prova especifica de matemática e valor da média do 12º ano. Defina a classe Ponto representada por duas coordenadas. ii. os métodos selectores e modificadores c.9 .

Não tinham nenhuma instrução que de alguma forma fizesse mudar o fluxo de execução da aplicação. Em alternativa: Tem duas possibilidades de blocos de instruções a executar. O que estas trazem de novo é a capacidade de controlar a execução de uma aplicação mediante o estabelecimento de condições lógicas. Ou seja. Instruções de Controlo Até aqui. todos os exemplos de código que vimos seguiam uma estrutura a que se dá o nome de sequencial. Existem essencialmente dois tipos de instruções de controlo: Selecção: permitem determinar o caminho a seguir de acordo com o valor de uma expressão. o bloco a executar é escolhido com base na condição cuja verificação tenha sido positiva.1 . ou executa um ou executa outro. A selecção de instruções pode ser: Simples: Com base na condição a avaliar executa um bloco de instruções ou então não executa. Resolver problemas mais complexos exige um maior poder de decisão sobre a forma como o programa é executado (fluxo de execução). Esta filosofia limita em muito a utilidade dos programas que se possam vir a produzir. dados fornecidos pelo utilizador.Selecção Ao implementar aplicações podemos ter que tomar decisões com base em valores de expressões.case Com estas instruções podemos concretizar cada um dos três tipos de selecções acima mencionados. 4. Deste tipo de necessidades surgiram as instruções de selecção: para impôr a execução condicional de instruções.Selecção Simples: if Um exemplo de uma selecção simples representado por um fluxograma pode ser o seguinte: Verdadeiro Expressão Instruções.. resultados calculados.. Em Java as instruções de selecção são as seguintes: if/else switch . as instruções são executadas uma após a outra de acordo com a ordem por que aparecem. Repetição: permitem controlar o número de vezes que um determinado bloco de instruções é executado (são os chamados ciclos). Com base na condição.1.1 . Múltipla: As possibilidades são várias e as condições a verificar também. Falso Fluxograma de uma instrução de selecção simples © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 58 . Sebenta da Disciplina de Introdução à Programação 4. etc. o que nos é possibilitado pelas instruções de controlo. 4.

Sebenta da Disciplina de Introdução à Programação

Começa por ser avaliada uma expressão lógica. Se o seu resultado for verdadeiro, então é executado um
determinado bloco de instruções. Caso contrário, a execução do programa prossegue sendo esse bloco ignorado.

Em Java, este tipo de selecção concretiza-se recorrendo à instrução if, cuja sintaxe é a seguinte:

if ( expressão ) instrução

Figura 28. Instrução de selecção if

Código exemplo para uma instrução if:

if (condição) {
instruções;
}

Exemplo 1:

public class TesteIdade
{
public static void main(String args[])
{
int idade = 14;
// Verificar se um individuo tem
// idade para conduzir
if (idade < 16)
System.out.println(“Muito novo para guiar”);
}
}

Exemplo 2:

// Programa que gera um número aleatório e informa se
// o número gerado é ou não negativo

import java.util.Random;

public class NumNeg
{
public static void main(String args[])
{
Random random = new Random();
int n = random.nextInt();
System.out.println(“n = ” + n);

if (n < 0)
System.out.println(“O número é negativo”);

System.out.println(“Adeus.”);
}
}

© Escola Superior de Tecnologia de Setúbal 2005-2006 Página 59

Sebenta da Disciplina de Introdução à Programação

Exemplo 3:
Relativamente à classe Aluno, do exemplo que temos vindo a acompanhar, implemente um método que retorne falso
se o valor da propina é igual a zero.

public boolean verificaValorPropina()
{
if (valorPropina == 0)
return false;
}

4.1.2 - Selecção Em Alternativa: if-else
Muitas vezes interessa-nos que, quando a condição a verificar seja falsa, haja um conjunto alternativo de instruções a
executar. É a isto que se dá o nome de selecção em alternativa, que, em termos de fluxograma pode ser representada
da seguinte forma:

B - Instruções... Falso Verdadeiro A - Instruções...
Expressão

Figura 29. Fluxograma de uma instrução com selecção alternativa

Recapitulando: Se a expressão for verdadeira, é executado o conjunto de instruções A. Se for falsa, é executado em
alternativa o conjunto de instruções B. O programa segue depois com as instruções que tiver para executar a seguir.

Em termos de sintaxe Java, este tipo de selecção representa-se da seguinte forma:

if ( expressão ) instrução

else instrução

Figura 30. Instrução de selecção if-else

© Escola Superior de Tecnologia de Setúbal 2005-2006 Página 60

Sebenta da Disciplina de Introdução à Programação

Código exemplo de uma instrução if/else:

if (condição) { // as chavetas aparecem quando há mais que
// uma instrução a executar dentro do if ou
// do else. Passa a ser composto!
instruções;
}
else {
instruções;
}

Exemplo 1:

public class TesteNota
{
public static void main(String args[])
{
int Nota = 14;

// Resultado da avaliação
if (nota < 10)
System.out.println(“Nota negativa”);
else
System.out.println(“Nota positiva”);
}
}

Exemplo 2:

// Programa que gera dois números aleatórios
// e informa qual deles é o menor.
import java.util.Random;

public class Menor
{
public static void main(String args[])
{
Random random = new Random();
int m = random.nextInt();
System.out.println("m = " + m);
int n = random.nextInt();
System.out.println("n = " + n);
if (m < n) // o que acontece se m=n?
System.out.println(“O menor numero e " + m);
else
System.out.println("O menor numero e " + n);
}
}

As instruções if podem ser representadas em paralelo ou encadeadas, caso haja várias alternativas a estudar e a
representar.

© Escola Superior de Tecnologia de Setúbal 2005-2006 Página 61

a<b<c sim a<c<b sim (b < c) ? sim c<a<b não (a < c) ? (a < b) ? não b<a<c b<c<a sim c<b<a não (a < c) ? sim não (b < c) ? não // código: if (a < b) if (b < c) System.println("c < a < b"). Sebenta da Disciplina de Introdução à Programação Exemplo 3: Relativamente à classe Aluno.out.out. else if (a < c) System. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 62 .out. else System.out. else return true. b. c) usando if’s encadeados. } Exemplo 4: // Determinar a ordem de grandeza // dos três números (a. else System.println("b < c < a"). else if (b < c) System. implemente um método que retorne falso se o valor da propina é igual a zero e verdadeiro se o valor for diferente de zero.println("a < c < b"). public boolean verificaValorPropina() { if (valorPropina == 0) return false.println("b < a < c"). else if (a < c) System.println("a < b < c").out.println("c < b < a").out.

Mas na realidade o código tem um erro de indentação e o else representa uma alternativa à condição numeroAluno < 2000.out.println("O aluno tem um numero entre 1201 e 1999"). Sebenta da Disciplina de Introdução à Programação // Determinar a ordem da grandeza // dos três números (a.out.. há uma nota importante a fazer.out.println("c < b < a"). Essencialmente. ou seja. a<b? b<c? a<b<c a<c? c<b? a<c<b b<a? a<c? b<a<c b<c? c<a? b<c<a c<a? a<b? c<a<b c<b? b<a? c<b<a // código: if (a < b && b < c) System. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 63 . if (b < a && a < c) System. if (c < b && b < a) System. Em relação ao uso específico da alternativa else. if (a < c && c < b) System.. em termos semânticos.out. Exemplo 5: if ( numeroAluno > 1200) if (numeroAluno < 2000) System. A que if pertence o else? Da forma como está escrito o código.println("c < a < b"). if (c < a && a < b) System. b.out. if (b < c && c < a) System.println("a < c < b").out.out.println("a < b < c"). ao tomar a decisão de usar if’s de forma encadeada ou em paralelo estamos apenas a ter em conta o facto de cada condição a verificar depender ou não das anteriores. parece ser dado a entender que o else representa a alternativa à condição numeroAluno > 1200.println("b < c < a"). c) usando if’s paralelos. else System..out.println("b < a < c").println("O aluno tem um numero inferior ou igual a 1200"). ser susceptível de interpretações diferentes numa mesma situação. tornar-se ambíguo. Há casos em que o else pode.

fazem parte do bloco de instruções a executar quando numeroAluno > 1200 tem o valor true. } } Aplicando a regra de que um else pertence ao último if deixado em aberto. dizemos que o segundo if e a mensagem que este envia para o canal de saída (caso a condição seja verdadeira). o interpretador não saberia o que fazer quando lhe surgisse um conjunto de instruções deste género. ao último if sem else.out.println("O aluno tem um numero inferior ou igual a 1200").nextInt().out. Neste caso. Tornámo-las numa instrução composta.println(" Deve melhorar "). o else pertence ao if onde se verifica se pontos > 95! © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 64 .println("O aluno tem um numero entre 1201 e 1999"). Se não tivesse sido estipulada à partida uma regra para o Java operar nestes casos. visualizar “Deve melhorar“ // Se tem mais que 95 pontos. visualizar “Trabalho // excelente!“ // Se tem entre 70 e 95. else System.in). int pontos = scanTeclado. Nota: Pode haver if’s sem else’s.out. } else System. a semântica da instrução if/else dita que um else "pertence" sempre ao if que foi deixado em aberto em último lugar. Sebenta da Disciplina de Introdução à Programação Não podem existir ambiguidades quanto ao caminho a seguir na execução de instruções. Exemplo 6: // Se tem menos que 70 pontos. para forçar a que o else estivesse associado ao primeiro if. teríamos de usar delimitadores: if ( numeroAluno > 1200) { if (numeroAluno < 2000) System.out. não visualizar mensagem // O código seguinte está certo ou errado? public class Pontos { public static void main(String args[]) { Scanner scanTeclado = new Scanner(System. Em Java. /* Sem as {} sabemos a que if pertence o else? E é esse o resultado desejado? */ if (pontos >= 70) if (pontos > 95) System.println(" Trabalho excelente!"). Na situação anterior. mas o contrário não se aplica. Ou seja.

. A máquina tem de saber sempre qual é a próxima instrução a executar. com base na avaliação de uma variável ou expressão de valor inteiro (ou caracter) escolhe.case Nos tipos de instruções de selecção descritos anteriormente verificámos que é possível utilizar diferentes formas da instrução if para seleccionar a alternativa que mais nos convém. Se o valor da expressão a executar não for igual a nenhum dos valores v1. Em termos semânticos. compara o valor da expressão com os valores v1 a vn.3 . Sebenta da Disciplina de Introdução à Programação Em termos sintácticos seria assim que a máquina virtual Java iria interpretar.1. entre várias alternativas possíveis.Selecção Múltipla: switch . claramente teríamos aqui um erro de interpretação do problema e os resultados não seriam os pedidos pelo enunciado. há uma alternativa pronta a ser executada quando mais nenhuma serve e é essa a escolhida (no fluxograma está representada pelo valor outro). Fluxograma de uma instrução de selecção múltipla Começa por calcular o valor da expressão que tem de ter um resultado de tipo inteiro ou caracter.. Em termos de fluxograma pode ser representada da seguinte forma: V1 V2 . Em Java. Depois. Se for igual ao de algum deles. executa o bloco de instruções correspondente. pode suceder uma de duas situações: não há mais nenhuma alternativa a considerar e portanto nenhum bloco de instruções a executar. pois não há margem para ambiguidades. A instrução switch é também uma instrução de selecção que. No entanto. a instrução que se usa para representar situações de selecção múltipla é a instrução switch. se a decisão a tomar tiver que ser feita com base num valor inteiro ou numa letra ao invés de um valor lógico. Vn outro Expressão I1 I2 In Id Figura 31. vn. 4. então a estrutura de selecção múltipla que vamos apresentar torna-se mais eficaz.. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 65 .. uma instrução ou conjunto de instruções a executar.

// por exemplo. se esta for a última). Nota: Esquecer um break onde ele deve ser usado. break.nextInt(). Há.println("A . Scanner scanTeclado = new Scanner(System. Embora a ordem dos cases e do default não esteja estipulada à partida. não é necessário. se o break nao estivesse aqui // e pontos/10 = 9. Instrução de selecção múltipla switch-case A instrução break após cada case serve para evitar que os próximos cases sejam executados. default } Figura 32. O break após a última instrução case (ou default. é considerada boa prática colocar o default em último lugar. no entanto.out. o bloco seguinte (do case 8) // era executado na mesma. A existência do default foca o programador na necessidade de processar condições excepcionais. Muitos programadores colocam-no apenas por uma questão de coerência e simetria para com as anteriores. conduz a erros lógicos ou semânticos.out. pontos = scanTeclado. Os cases que não sejam explicitamente programados num switch sem default são ignorados. Exemplo 1: public class Pontos { public static void main(String args[]) { int pontos. conduzindo a um erro! © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 66 .print (“Digite um inteiro entre 1 e 100:> “).Excelente!"). Sebenta da Disciplina de Introdução à Programação switch (expressão) { case constante : instrução break . situações em que a utilização do default não é necessária. System.in). Se há um case que tem o mesmo valor da expressão o seu bloco de instruções deve ser executado e o break faz com que a instrução switch seja terminada. switch (pontos/10) { case 10: case 9: System. O default é o caso que deve ser executado quando mais nenhum serve (segundo o fluxograma é a opção outro).

case ‘A’: case ‘B’: case ‘C’: case ‘D’: case ‘E’: case ‘F’: return (ch – ‘A’) + 10. break. switch (ch) { case ‘0’: case ’1’: case ’2’: case ’3’: case ’4’: case ’5’: case ’6’: case ’7’: case ’8’: case ’9’: return (ch – ‘0’). case ‘a’: case ‘b’: case ‘c’: case ‘d’: case ‘e’: case ‘f’: return (ch – ‘a’) + 10. ou y>100 && y>200.in).out. break.Bom trabalho!").”).out.out. case 6: System.out.nextChar().Pode fazer melhor!").print(“Adeus.println("C .println("F – Vai trabalhar!").Falamos depois da aula. default: System.out. ) © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 67 . } } } // Não há breaks porque cada expressão tem um return que // sai do bloco antes que se tente sequer avançar para o próximo! If Versus Switch O if é apropriado para testes em expressões que representem valores lógicos O switch faz selecções com base expressões cujos valores sejam inteiros Utiliza-se o if quando O número de alternativas é pequeno Queremos impor uma ordem na avaliação da expressão A escolha é baseada em gamas de valores (tipo x>1. Sebenta da Disciplina de Introdução à Programação case 8: System. default: System. case 7: System.println(“B .. break. } } } Exemplo 2: public class TestaCaracter { public static void main(String args[]) { Scanner scanTeclado = new Scanner(System.").. char ch = scanTeclado.println("D .

Este tipo de situações é absolutamente indesejável pois se um ciclo não termina o programa não avança e. Quando um ciclo não tem fim. Sebenta da Disciplina de Introdução à Programação Utiliza-se o switch quando Se testam expressões cujos resultados são valores de tipos enumeráveis (inteiros. Se há uma tarefa que deve ser executada 500 vezes.2 . mas ainda por cima torna o código mais susceptível a erros que para serem corrigidos nos obrigam a percorrer cada um dos blocos de instruções que programámos repetidamente. Não só deixa de ser produtivo. ou seja. por exemplo.1 . é cansativo e desmotivante. diz-se que se trata de um Ciclo Infinito. não vamos escrever 500 vezes o mesmo bloco de código. É normalmente composto por: Corpo: conjunto de instruções a repetir Uma condição ou outra estrutura que controla a execução do corpo. Fluxograma de uma instrução de repetição while © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 68 . consequentemente. As instruções que nos permitem resolver este tipo de problemas de uma forma mais eficaz são as instruções de repetição. Em Java ( e na maioria das linguagens de programação de alto nível).2.Repetição É fundamental que uma linguagem de programação dê suporte à repetição de tarefas. o corpo continua a ser executado. Para além disso. repete as instruções do corpo indefinidamente. Um ciclo é uma sequência de instruções executada de forma repetitiva e sujeita a uma condição de término. De acordo com o que nos mostra o fluxograma seguinte. não só por uma questão de eficiência mas também de produtividade. caracteres) 4. a sua execução também não terá fim nem produzirá resultados. há três tipos de instruções de repetição: while do-while for 4. corremos o risco de esgotar os recursos do computador rapidamente se durante esse ciclo interminável houver operações exigentes em termos de requisitos de memória. também conhecidas por ciclos. Expressão Instruções Verdadeiro Falso Figura 33. o que vemos é que enquanto a condição tiver o valor verdadeiro (true).Instrução de Repetição while Esta instrução de repetição baseia-se na avaliação de uma condição lógica para determinar a continuação (ou não) da execução do corpo do ciclo. especificando de alguma forma a quantidade de vezes que este deve ser executado (número de iterações).

O corpo do ciclo pode ser uma instrução simples ou composta. public class NumeroPrimo { public static void main(String[] args) { © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 69 .println(“A é “ + a + “B é “ + b). Isto é. Isso consegue-se fazendo com que uma das instruções do corpo do ciclo se encarregue de mudar o valor da condição no momento apropriado. Exemplo 1: public class CicloWhile { public static void main(String args[]) { int a=30. } } } // qual é o resultado produzido? Exemplo 2: /* Programa que gera um número entre 1 e 100 é verifica se o número é primo (primo é um número maior que 2 e que é divisível somente por si próprio e por 1) */ import java. pode haver uma ou mais instruções a repetir. i=3. } Após uma pequena análise dos diagramas e sintaxes apresentados acima. b=15.Random. System. Se a condição a verificar tiver à partida o valor false. Para que o ciclo não se torne infinito. o ciclo não chegará a ser executado. i--. while (i>0) { a-=10. temos de garantir de alguma forma que a expressão avaliada a cada passagem chegará a ter o valor false. Sebenta da Disciplina de Introdução à Programação while ( expressão-lógica ) instrução Figura 34.util. Essas instruções são repetidas enquanto a condição a avaliar em cada passagem for verdadeira. b-=5. há algumas pequenas notas a fazer: A avaliação da expressão ou condição tem que ter obrigatoriamente como resultado um valor lógico (true ou false). Instrução de repetição while Código exemplo de uma instrução while: // as chavetas aparecem se houver mais do que uma instrução // a executar no corpo do ciclo while(condição){ instruções.out.

println(x + " e primo. no sentido em que executa o corpo do ciclo enquanto a condição a avaliar for verdadeira. ou seja. int x = random. o do-while comporta-se de maneira ligeiramente diferente: primeiro executa o corpo do ciclo e só depois avalia o valor da condição de paragem."). while (primo && d <= x) primo = (x % d++ != 0). Por avaliar a condição no fim.2."). um while pode nunca chegar a executar o corpo. System. Diz-se que o while executa 0 ou mais vezes. i=0. um do-while executa sempre o corpo pelo menos uma vez.2 . } } Exemplo 3: public class CicloInfinito { public static void main(String args[]) { int a=0. O do-while executa 1 ou mais vezes. ++i.println(“A é “ + a).out. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 70 . if (primo) System. Devem respeitar-se as mesmas regras para evitar a geração de ciclos infinitos. } } // Este é um exemplo a não seguir! 4.nextInt(100)+1.out. Sebenta da Disciplina de Introdução à Programação int d = 2. Random random = new Random(). Apesar de o modo de funcionamento ser aparentemente o mesmo. } while (i > 0).println(x + " não é primo. do { ++a.Instrução de Repetição do-while A instrução de repetição do-while é semelhante à anterior (while). há que garantir que no corpo do ciclo existe alguma instrução que no momento certo muda a o valor da condição por forma a quebrar o ciclo. Isto faz com que se gere uma nuance que marca toda a diferença: Por avaliar primeiro a condição. se a condição for falsa logo à partida.out. else System. boolean primo = (x > 1).

println(“A é “ + a). © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 71 . System. um do-while pode representar-se da seguinte forma: Instruções Expressão Verdadeiro Falso Figura 35. ++i. } while (i<3). Sebenta da Disciplina de Introdução à Programação Em termos de fluxograma. Exemplo 1: public class CicloDoWhile { public static void main(String args[]) { int a=0. Instrução de repetição do-while Código exemplo para uma instrução do-while: do { // as chavetas aparecem quando o corpo do ciclo tem // mais do que uma instrução a executar! instruções. } } // qual é o resultado produzido? Exemplo 2: Programa que gera um número entre 1 e 100 e verifica se o número é primo. Fluxograma da instrução de repetição do-while do instrução while ( ) expressão-lógica Figura 36. i=0. do { ++a. } while(condição).out.

while (primo && d < n).out. if (primo) System.println(n + " é primo.println(n + " não é primo.out.nextInt(100)+1. particularmente quando se conhece de antemão a quantidade de iterações necessárias (ou seja.Instrução de Repetição for A instrução for é outra instrução de repetição muito útil. int d = 2. Sebenta da Disciplina de Introdução à Programação import java.3 . regra geral. public class Primo { public static void main(String[] args) { boolean primo. A execução do corpo do ciclo for está. senão termina Conclusão: A instrução do-while executa o bloco de instruções uma ou mais vezes A instrução while executa o bloco de instruções zero ou mais vezes 4. } } Recapitulando: A instrução de repetição while começa por avaliar a expressão : Se for verdadeira entra no ciclo Executa instrução ou bloco de instruções internas ao ciclo A cada nova iteração re-avalia a expressão lógica Se a expressão se tornou falsa o ciclo termina A instrução do-while: Executa o bloco de instruções internas ao ciclo Avalia a expressão Se for verdadeira continua o ciclo."). dependente da avaliação do valor de uma variável de controlo.2.").Random. o número de vezes que se pretende repetir o corpo do ciclo). do primo = (n % d++ != 0).util. int n = random. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 72 . else System. Random random = new Random().

um for poder-se-ia representar da seguinte forma (seguindo literalmente a especificação do ciclo): Verdadeiro Expressão Instruções Falso Aplica Experssão 3 a Experssão 1 Figura 38. é a expressão que inicializa o ciclo atribuindo um valor inicial à variável de controlo. Avalia expressão2 (o teste que é efectuado em cada ciclo). Fluxograma da instrução de repetição for © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 73 . expressão ) lógica instrução Figura 37. expressão .expressão3){ instruções } O modo de funcionamento é o seguinte: Parte de expressão1. Instrução de repetição for Código exemplo para a instrução de repetição for: for(expressão1. Sebenta da Disciplina de Introdução à Programação for ( expressão .expressão2. Se é verdadeira: executa instrução executa incremento (instrução que altera o valor da variável de controlo) determinado por expressão3 para a variável de controlo de expressão1 regressa ao passo 2 Se é falsa: Termina o ciclo Em termos de fluxograma.

println(n + " não é primo. i++) { a+=10. ao ser declarada no cabeçalho do ciclo. return.").nextInt(100)+1. Se tentarmos usá-la fora do ciclo obtemos um erro de sintaxe. Sebenta da Disciplina de Introdução à Programação Notas: Num ciclo for. System. } } } Exemplo 2: // Programa que gera aleatoriamente um número entre 1 e 100 // e verifica se o número é primo. int n = random. d++) if (n%d == 0) { System. para separar as expressões do cabeçalho do for. } } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 74 .Random.out. ao invés de pontos e virgula.out. imediatamente a seguir ao ) do cabeçalho do for. só é conhecida dentro do seu corpo. Para conseguir esse efeito devemos declará-la antes do cabeçalho do ciclo (a inicialização pode."). ou não. public class Primo { public static void main(String[] args) { Random random = new Random(). Um erro comum de programação consiste em usar virgulas. a variável de controlo. devemos ter em atenção que. isto porque assim o ciclo não tem corpo e passa a executar uma sucessão de instruções vazias. Exemplo 1: public class CicloFor { public static void main(String args[]) { int a=0. i<3. import java. Normalmente geram-se erros semânticos/lógicos se colocarmos um . for (int i=0. b=0.println(“A é “ + a + “B é “ + b). b+=5. d < n.out.println(n + " é primo.util. ser feita nesse cabeçalho). for (int d = 2. } System.

gerando portanto um ciclo infinito. apesar de tal ser possível e de produzir um código mais compacto. for (int x = 1.out. o interior também terá a sua chance de realizar trabalho. Desde que o exterior reúna as condições para prosseguir. ou seja. while versus do-while. Quando o número de repetições não é conhecido à partida. Podemos omitir a expressão1 se inicializarmos a variável de controlo antes do ciclo. aumentamos toda a complexidade da solução. ter ciclos dentro de ciclos. versus for Após sabermos como funciona cada tipo de instrução de repetição reside ainda uma questão por resolver: qual delas deve ser usada em cada situação? Um ciclo for. por norma também é mais difícil de ler e compreender caso tenhamos de corrigir erros. Sebenta da Disciplina de Introdução à Programação Todas as 3 expressões do cabeçalho do for são opcionais: Se omitirmos a expressão2. x++) { for (int y = 1. o Java assume que a condição de continuação do ciclo é true. o for é flexível o suficiente para que possa ser utilizado em situações onde o número de repetições seja também controlado por uma condição lógica e em que o número de repetições não seja conhecido de antemão. Exemplo 3: public class CiclosEncadeados { public static void main(String[] args) { final int SIZE = 5. y++) { int z = x*y. No entanto. estando a execução do bloco de instruções dependente apenas de uma condição lógica. devemos então utilizar o while. usa-se essencialmente quando o número de repetições é conhecido antes do início da sua execução. Ciclos Encadeados Tal como podemos ter instruções de selecção encadeadas. } } } Nota: Não é aconselhável encadear muitos ciclos uns nos outros.out. x <= SIZE. Podemos omitir a expressão3 se o programa calcular o incremento ou decremento com instruções dentro do corpo do ciclo. Uma métrica razoável seria nunca utilizar mais do que três ciclos encadeados. y <= SIZE. também podemos ter ciclos encadeados. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 75 . ou seja.print(" " + z). if (z < 10) System. Em Java.out.println(). System. } System. Torna muito mais difícil a manutenção do código e a resolução de problemas. A regra dita apenas que o ciclo mais interior é o último a ser executado.print(" ").

println ("laranja"). System. 1: Para os exercícios seguintes indique o output que espera como resultado. O que são ciclos infinitos? Grupo II Exerc. } else System. O que é um ciclo? Qual é a motivação que encontra na utilização de instruções de repetição? 9.out. int num1 = 12.out. É possível codificar ciclos encadeados? Quais são as limitações que encontra neste tipo de solução? 11.out. Sebenta da Disciplina de Introdução à Programação Devemos usar um ciclo do-while em situações em que o bloco de instruções a repetir.println ("maçã"). O que representa a opção de default? 8. } System.println ("pera").out.println ("laranja"). deva ser executado pelo menos uma vez. para que servem as instruções de controlo? 3. Para que serve a utilização da instrução break no código de um switch? 7. Quais são as instruções de repetição que conhece? Quais as diferenças entre elas? Quando acha que deve utilizar cada uma? Justifique cada passo da resposta. num2 = 25. Na sua opinião. LIMIT = 100.3 .out. 4.out. Alínea A if (num3 >= LIMIT) System. Aliás.out. para além de estar dependente da avaliação de uma condição lógica.println ("pera").Exercícios Práticos Grupo I 1. 4. Qual é o objectivo da instrução if? E do switch? Quais as diferenças entre estas duas instruções de selecção? Em que tipo de situações se deve usar uma ou a outra? Justifique todos os passos da resposta. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 76 . System.println ("laranja"). tendo em conta a declaração e inicialização das seguintes variáveis: final int MAX = 25. é esse o ponto que marca a diferença entre um do-while e os outros dois tipos de instruções de repetição.println ("maçã"). 10. Ao utilizar o if tem de utilizar sempre e obrigatoriamente um else? Se não for o caso indique a que situações se aplicam a utilização do else.println ("maçã"). Alínea B if (num2 == MAX) { System. Alínea C if (LIMIT+num3 <= 150) { System. System.out. System. 5. Verdadeiro ou falso? 6. num3 = 87.println ("pera").out. Que tipos de instruções de controlo conhece? 2. É possível ter instruções if encadeadas ou paralelas.

Alínea G if (num3 >= MAX) { if (MAX/num2 == 1) System. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 77 .println ("banana").out.println ("maçã"). } else { System. Alínea H if (LIMIT >= 4*num2) if (MAX == 25) System. System.println ("laranja"). else { System.out.println ("laranja").println ("laranja").println ("maçã").out.println ("laranja"). Alínea E if (LIMIT%num1 + 4 == num1 + (MAX-num2)) { System.println ("kiwi").out.out.out. System.println ("maçã"). else System.out.out.println ("pera"). Sebenta da Disciplina de Introdução à Programação Alínea D if (num1 < MAX) if (LIMIT >= num2) System.out. System.println ("uva").println ("pera").out. System.println ("maçã").println ("laranja").out. } Alínea F if (num2 > 18) if (num1 < 0) System.out..out.println ("pera").println ("pera").println ("banana").out. } } else if (num2*2 == MAX*2) System.println ("maçã").out. else System. else System. System.out.out. if (LIMIT-num3 > num1+2) System.out. System.

println().println (num). } Alínea D while (num > MIN) { System. count2 <= 5. 2: Para os exercícios seguintes escreva segmentos de código que sirvam para executar as acções indicadas: Alínea A Imprimir “Hurra!” se a variável sum for divisível por count Alínea B Imprimir “Num é zero”.print (count1*count2 + " ").out. Imprimir “Diferente” se não forem de todo iguais ou semelhantes. Alínea C Atribuir o valor mais pequeno de dois inteiros à variável smallest utilizando: If-else Operador condicional Alínea D Imprimir “Igual” se dois valores do tipo float guardados em val1 e val2 forem exactamente iguais e “Essencialmente igual” se esses dois valores estiverem a uma distância inferior ou igual a 0. count2++) System. “Num é negativo”. MAX = 20. count1 <= 5.1.out. int num = 15. Alínea A while (num < MAX) { System.0001 um do outro.out. System. count1++) { for (int count2=1. } Alínea B do { num = num + 1. consoante o valor de num. “Num é positivo”. } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 78 .println (num). num = num . Sebenta da Disciplina de Introdução à Programação Exerc.: Exerc. num = num + 1.println (num).out. 3: Nos seguintes exercícios indicar o output que irá ser produzido tendo em conta o valor de base das seguintes variáveis: final int MIN = 10. Alínea C for (int count1=1.out. System. } while (num <= MAX).

10. Exerc.println(value). 2: Implemente um método que receba um caracter e determinar se este corresponde a um dígito. value--) System. case 2: c=33. value < 0. caso existam. Grupo III Exerc. 4: Implemente um método que receba um número inteiro e verifique se é divisível por 2. } while (num <= MAX). Sebenta da Disciplina de Introdução à Programação Alínea E while (num < MAX) { if (num%2 == 0) System. if (num*2 > MAX+num) System.println (value).000 5% >= 100 000 e < 300 000 15% > 300 000 25% Tabela 1 Exerc. Exerc. Exerc. d=44. os erros existentes: switch(n) { case 1: a=11. 3. 1: Implemente um método que receba um número e indique se o número é par ou ímpar. break. Alínea H for (int value=num. 5.out. 3: Implemente um método que receba um determinado número e informe o utilizador se o mesmo é divisível por 5. break. 6: Observe o código da figura seguinte e indique. 5: Implemente um método chamado. } Alínea F for (int value=7. Alínea G do { num = num + 1. num++. value++) if (value%4 != 0) System. value <= MAX. calcIRS.out. 15 ou 30. Exerc.out. b=22.println (num). 6.out. que receba o ordenado de um trabalhador e devolva o imposto a pagar de acordo com a tabela 2: Ordenado Taxa <100.println (num). } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 79 .

“ + fib1). b) receber dois números obtidos aleatoriamente e retornar o resultado da operação matemática entre ambos. Exerc. System. constituída pelos seguintes métodos: a) gerar um número aleatório. de acordo com a potência do motor.) e leva uma comissão de 2% do valor transaccionado mais 1 Euro.“ao quadrado é igual a ”. 7: Crie uma classe. int fib0 = 0. um programa usa um de três procedimentos. fib1=fib2. Exerc. chamada Principal./) Crie outra classe. Exerc. um conjunto de instruções equivalente a: while (i<100) System. dependendo do operador escolhido (+. que permita testar os métodos desenvolvidos na classe Utilitaria. A quantidade de números é desconhecida à partida. fib2=fib0 + fib1. int fib2 = 1. etc. chamada Utilitaria. *.print(“ . Ao processar informação sobre um destes motores. constituída pelos seguintes métodos: a) ler um número inteiro. Francos. As taxas de câmbio existem no programa como constantes.sqr(i)). Exerc. Partindo do princípio que o programa está escrito em Java e de que a variável inteira Pot representa a potência do motor a ser fabricado. Crie outra classe. caso existam.Math.out. escreva uma instrução if que execute o procedimento correspondente de acordo com a tabela seguinte: Potência do motor Acção a executar Pot < 1 Mensagem de erro 1 <= Pot < 5 PW1 5 <= Pot < 20 PW2 20<= Pot < 100 PW3 Pot >= 100 Mensagem de erro © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 80 . A sequência de entrada só termina quando for introduzido um número negativo. que correspondem a três lados de um triângulo e que classifique o triângulo como equilátero. O programa recebe a quantia e tipo de moeda a adquirir. int fib1 = 1. 12: Observe o código da figura seguinte e indique. b) Calcular a soma de um conjunto de números. os erros existentes: public class Exercicio { public static void main(String [ ] args){ System. utilizando um ciclo “for”. Sebenta da Disciplina de Introdução à Programação Exerc.print(0). Exerc. chamada Utilitaria. 10: Implemente um método que recebe um valor n e calcule a soma de n primeiros números positivos. Exerc.println(i. -. while (fib2<1000). 8: Implemente um método que receba três valores reais. 13: Um banco venda moeda estrangeira (Dólares. isósceles ou escaleno. { fib0=fib1. 11: Escreva.out. 14: Uma certa empresa fabrica motores com potências compreendidas entre 1 e 99cv. 9: Crie uma classe. que permita testar os métodos desenvolvidos na classe Utilitaria. } } Exerc. Libras. chamada Principal.out. Escreva um programa para indicar qual o valor a pagar por uma certa venda de moeda.

Exerc. imprimir um menu que permita ter as seguintes opções: inserir. utilizando uma estrutura de if’s encadeados e que verifique o limite superior das gamas de cada uma das notas qualitativas. apagar e procurar aluno e sair do programa. Parta do princípio de que não há movimentos na conta e de que os juros só são calculados no fim do número de meses especificado. 15: Escreva um programa em Java que converta notas quantitativas de 0 a 20 em notas qualitativas de mau a excelente. o número de meses ao fim do qual queremos calcular o saldo. criada no capítulo 3. Sebenta da Disciplina de Introdução à Programação As condições das instruções if não devem ter conjunções. O programa deverá ter a multa representada por uma constante. listar. 17: Relativamente à classe Aluno. tratar as opções do menu anterior. 16: Escreva um programa em Java para calcular os juros e o novo saldo de uma conta bancária. Deverá ler o saldo anterior. Exerc. Considere que: 0-4 : Mau 5-9 : Medíocre 10-13 : Suficiente 14-17 : Bom 18-20 : Muito Bom Exerc. tendo em atenção que se o saldo for inferior a 1. verificar se a nota da prova específica foi inferior a 12 valores (invoque o método que calcula a média e o implementado na alínea anterior). e a taxa de juros anual.000 a conta não recebe juros e paga uma taxa ao banco (multa). © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 81 . Caso a conta atinja um saldo negativo é cancelada. implemente os seguintes métodos: retornar falso se a nota da prova específica de matemática foi inferior a 12 valores.

Sebenta da Disciplina de Introdução à Programação

5- Tópicos Avançados de Classes

Como referido no livro “Fundamentos de Programação em Java2, FCA”, numa linguagem orientada a objectos os
programas funcionam através da criação de objectos, dos comportamentos que estes são capazes de apresentar e da
comunicação entre eles. Um objecto pode solicitar a outro um determinado comportamento, de entre os que estão
definidos. Antes de criar um objecto é necessário ter um “molde” que defina os seus atributos e comportamentos, o
qual se denomina por classe. Antes de se criar um objecto é necessário criar a respectiva classe. Podem ser criados
diversos objectos a partir de uma classe, cada um com atributos próprios mas com os mesmos comportamentos.
As linguagens de programação orientadas a objecto incluem diversas classes predefinidas a partir das quais se
podem criar objectos. Contudo, para a maioria dos programas é necessário definir novas classes de forma a poder
criar objectos que satisfaçam as necessidades dos programadores.
No JAVA, a definição de classes segue a seguinte sintaxe:

public class nomeDaClasse
{
//Declarações de atributos

// Construtores

// Métodos
}

As variáveis ou atributos, os construtores e os métodos de uma classe são genericamente denominados membros da
classe.

5.1 - Variáveis de Instância e variáveis de Classe
Numa classe podem ser declaradas variáveis de dois tipos: variáveis de instância e/ou variáveis de classe.

As variáveis de instância são as variáveis definidas para armazenar os atributos específicos de cada objecto, por
exemplo a cor, o peso, etc. Cada objecto da classe definida tem a cor e o peso como atributo embora os seus valores
possam ser diferentes para cada objecto.

As variáveis de classe não existem nos objectos. A declaração de uma variável de classe provoca a criação de uma
variável em memória, a qual será partilhada por todos os objectos que forem criados a partir da classe. Assim, as
alterações efectuadas por um objecto ao valor de uma variável de classe manifestam-se quando a mesma variável é
acedida por qualquer objecto da mesma classe. Este tipo de variáveis utiliza-se quando é necessário partilhar
informação entre objectos de uma classe ou aglutinar informação produzida pelos mesmos.

Como exemplo de uma variável de classe, podemos considerar uma situação em que se tenha interesse em saber
quantos alunos existem. A solução passa pela criação de uma variável de classe da classe Aluno que seja
incrementada quando for criado um novo objecto:

public static int numeroDeAlunos = 0;

A palavra reservada static indica ao compilador que deve criar uma variável que é partilhada por todos os
objectos da classe e como tal não deve criar uma cópia da variável sempre que for criado um novo objecto.

© Escola Superior de Tecnologia de Setúbal 2005-2006 Página 82

Sebenta da Disciplina de Introdução à Programação

Da mesma forma que existem variáveis estáticas também existem métodos estáticos. Os métodos estáticos podem
ser invocados sobre a classe, não é necessário criar nenhuma instância da classe (i.e. um objecto) em que foram
declarados para os podermos utilizar (um bom exemplo disto são os métodos definidos na classe Math).
Os métodos estáticos apenas podem manipular variáveis locais ou então atributos estáticos pois as variáveis de
instância só são criadas quando são criadas instâncias da classe.
A figura seguinte apresenta um exemplo de utilização de atributos e métodos estáticos.

// Demonstração de utilização de atributos e métodos estáticos
// Utilizando uma versão simplificada da classe Aluno

// versão simplificada da classe Aluno
public class Aluno {

// VARIÁVEIS DE CLASSE
static private int numeroDeAlunos = 0;

// VARIÁVEIS DE INSTÂNCIA
private String nome;
private int numero;

//CONSTRUTORES
public Aluno( String nom)
{
nome = nom;
numero = this.numeroDeAlunos++ +1;
}

// método estático – pode ser invocado sem ser criado
// nenhum objecto
public static int getNumeroDeAlunos()
{
return numeroDeAlunos;
}

// selectores
public int getNumero()
{
return numero;
}
public String getNome()
{
return nome;
}
}

// Exemplo de utilização de atributos e métodos estáticos
public class ExemploVariaveis {

public static void main(String[] args) {
// Declaração de 3 variáveis do tipo aluno
Aluno aluno1, aluno2, aluno3;

© Escola Superior de Tecnologia de Setúbal 2005-2006 Página 83

Sebenta da Disciplina de Introdução à Programação

System.out.println();
System.out.print("Número de Alunos existentes :");

//Chamada do método estático da classe Aluno
System.out.println( Aluno.getNumeroDeAlunos());

// criar 1º aluno com o nome "António"
aluno1 = new Aluno("António");

//Imprimir o número de alunos criados
//utilizando um método da classe
System.out.print("Número de Alunos (via classe): " +
Aluno.getNumeroDeAlunos());

//Imprimir o número de alunos criados utilizando o objecto aluno1
System.out.print("Número de Alunos (via aluno1): " +
aluno1.getNumeroDeAlunos());

// criar 2º aluno com o nome "Maria"
aluno1 = new Aluno("Maria");

// Obter o nome e número do 1º aluno criado
System.out.println("Nome: " + aluno1.getNome());
System.out.println("Número: " + aluno1.getNumero());

// Obter o nome e número do 2º aluno criado
System.out.println("Nome: " + aluno1.getNome());
System.out.println("Número: " + aluno1.getNumero());

//Imprimir o valor da variável de classe
//que representa o nº de alunos

//Imprimir o número de alunos criados
//utilizando um método da classe
System.out.print("Número de Alunos (via classe): ");
System.out.println(Aluno.getNumeroDeAlunos());

//Imprimir o número de alunos criados utilizando o objecto aluno1
System.out.print("Número de Alunos (via aluno1): ");
System.out.println(aluno1.getNumeroDeAlunos());

//Imprimir o número de alunos criados utilizando o objecto aluno2
System.out.print("Número de Alunos (via aluno2): ");
System.out.println(aluno2.getNumeroDeAlunos());

}
}

Figura 39. Demonstração de utilização de atributos e métodos estáticos utilizando uma versão simplificada da classe
Aluno

© Escola Superior de Tecnologia de Setúbal 2005-2006 Página 84

private int numero. dentro de um bloco de um método. private int ano.Encapsulamento O conceito de encapsulamento representa o princípio que cada objecto deve ser responsável pelos seus próprios dados e deve controlar o seu funcionamento. Os métodos que implementam os serviços fornecidos pelo objecto devem ser declarados public para que possam ser chamados a partir de outros objectos. 5.O Operador de Auto-Referenciação this A palavra reservada this pode ser utilizada. i. Esta perspectiva apenas interessa ao programador que criou a classe. 5. private e protected. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 85 . private char turma. ou seja. Estes pedidos correspondem ao conjunto de comportamentos definidos como públicos na classe do objecto. que apenas responde a um determinado conjunto de pedidos que lhe podem ser feitos por outros objectos. Numa perspectiva externa. pelo que não podem ser directamente utilizados a partir de outros objectos. Para obter este nível de independência. Esta perspectiva permite a reutilização do código do objecto uma vez que os detalhes internos de um objecto são independentes do contexto da sua utilização. A perspectiva interna tem a ver com a estrutura dos seus dados e com os algoritmos utilizados para implementar os seus comportamentos. Sebenta da Disciplina de Introdução à Programação 5.3 . this é um “apontador” ou uma referência para o objecto em questão. private String curso. // exemplo de utilização de this com a classe Aluno … //ATRIBUTOS private String nome. Os métodos que não pertencem à interface são métodos utilizados para auxiliar a implementação dos serviços e devem ser declarados como privados.2 . ele é público e pode ser acedido a partir de qualquer ponto do programa. as variáveis de instância dos objectos devem ser declaradas com visibilidade private. acessíveis do exterior. Denomina-se por interface do objecto o conjunto de serviços (o conjunto de métodos) disponibilizados pelo objecto. para referir o objecto actual. this é criado automaticamente quando um objecto chama um método e “aponta” para o próprio objecto que chamou o método. Usando este apontador. O modificador de visibilidade protected tem a ver com o conceito de herança o qual não é abordado no âmbito desta disciplina. Como regra geral. Para o exterior basta dar a conhecer os comportamentos possíveis e os seus efeitos. Os membros declarados como private são privados e como tal só são visíveis e dentro da classe onde estão declarados.4 . qualquer alteração do seu estado (das suas variáveis) deve ser provocada apenas pelos seus métodos e não deve permitir que outro objecto altere o seu estado. um método pode aceder a todas os atributos da classe a que pertence.e. pois só este necessita de conhecer os seus detalhes internos. mesmo por objectos de outras classes. um objecto é visto como uma entidade encapsulada. um objecto deve ser auto-contido. mas não a forma como são implementados Um objecto pode ser considerado sob duas perspectivas: a interna e a externa..Modificadores de visibilidade Na linguagem Java existem três modificadores de visibilidade que permitem controlar as permissões de acesso a um membro da classe: public. Um objecto deve funcionar como uma caixa negra que é capaz de apresentar um conjunto de comportamentos se for solicitado. Quando um membro de uma classe é declarado com o modificador public.

Passagem por Parâmetros Referenciados Como foi referido anteriormente. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 86 ."EI". estamos a passar uma cópia da referência para o mesmo. char turma) { this. this. 2133. valorPropina=0.out. // passagem “por referencia” de aluno mudaNomeAluno(aluno).turma=turma. a passagem de parâmetros é sempre feita por valor.getNome()). // escreve o nome do aluno – "João" System. 5. //CONSTRUTORES public Aluno(String nome. int numero.getNome()).nome = nome. 'A').nome estamos a referenciar a variável de instância nome pertencente ao objecto que está a ser criado. Caso contrário como saberíamos de que nome. int ano.out.numero =numero.5 . } Figura 40. Ao passar como parâmetro para um subprograma uma variável que representa um destes tipos. // escreve o nome do aluno após alteração no subprograma – "José" System. Isto significa que.ano=ano. curso ou turma se estava a falar? Quando se utiliza this. Contudo. as alterações efectuadas sobre um objecto recebido como parâmetro de um método reflectem-se fora do mesmo. As variáveis que representam objectos são na realidade referências (apontadores) para zonas de memória onde estes estão armazenados. String curso. Isto provoca um comportamento idêntico ao da passagem por referência.println( aluno. Sebenta da Disciplina de Introdução à Programação private double valorPropina. Todos os tipos de dados em Java que não sejam primitivos são objectos. 1. evitando deste modo a confusão com o parâmetro nome do método construtor Aluno. quando se passa um objecto como parâmetro. // exemplo de passagem por parâmetros referenciados public class Referencia { public static void main(String[] args) { Aluno aluno = new Aluno("João". Exemplo de utilização de this com a classe aluno Neste caso o operador this ajuda ainda a resolver ambiguidades.println( aluno. em Java. ano. Deste modo. this. na realidade o que é passado é o valor da referência do objecto e não o objecto propriamente dito. this. estamos na realidade a alterar o objecto e quem chamou o subprograma vê essa alteração. this. private double valorPago. se dentro do subprograma fizermos alguma operação sobre essa variável. valorPago=0.curso=curso. numero.

mas diferentes assinaturas. int numero. this.numero =numero. Sebenta da Disciplina de Introdução à Programação } public static void mudaNomeAluno( Aluno aluno1) { aluno1. this. int ano.turma=' '. Como exemplo podemos ver a figura seguinte onde são definidos dois construtores para aluno. this. } Figura 42. Exemplo de sobrecarga do construtor © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 87 . na classe String existem diversos métodos valueOf. por exemplo: static String valueOf(boolean b) static String valueOf(char c) static String valueOf(char[] data) static String valueOf(boolean b) A sobrecarga de métodos é bastante utilizada no caso dos construtores. this. String curso) { this. } public Aluno(String nome. this.nome = nome.nome = nome. this.curso=curso.ano=1.numero =numero. } } Figura 41. this.ano=ano. os quais podem ser utilizados conforme a informação disponível na altura da criação do objecto da classe Aluno. valorPago=0.curso=curso. String curso. Por exemplo.setNome("José"). valorPropina=1000. int numero. this. public Aluno(String nome. Exemplo de passagem por parâmetros referenciados 5.6 .turma=turma. valorPago=0.Sobrecarga de Métodos O Java permite a sobrecarga de métodos. valorPropina=1000. Diz-se que existe sobrecarga de métodos sempre que numa classe existem vários métodos com o mesmo nome. char turma) { this.

print(" ** "). Como pode criar e utilizar variáveis de classe? Isto é.descricao = "Ola". public static void main(String[] args) { VariavelDeClasse v1 = new VariavelDeClasse().7 . 1: Indique qual o resultado visualizado no ecrã após a execução do seguinte programa: public class VariavelDeClasse { static int n = 2. Diga o que entende por variável de classe e variável de instância.out. VariavelDeClasse.n++.Exercícios Práticos Objectivos da Série: Com esta série de problemas pretende-se que o aluno: • Saiba diferenciar e utilizar variáveis de instância e variáveis de classe.n). quais são os passos a dar? Justifique e dê exemplos. indique onde se encontra uma variável de classe e uma variável de instância. System. 3. Sebenta da Disciplina de Introdução à Programação 5.n = 1.print(v2. 5. 4. System.n = 2.out. String descricao. 2. Métodos estáticos podem referenciar atributos que não sejam estáticos? Justifique.n).print(v2. System.print(v1. Para utilizar uma variável e/ou um método estático de uma classe necessita de instanciar a classe? Justifique. VariavelDeClasse v2 = new VariavelDeClasse(). v1.out. System. System.descricao + " "). O que é e para que serve o operador this? Parte II – Aplicação de Conceitos Usando Pequenos Programas Exerc. Mencione as diferenças entre ambas e justifique a resposta.out. } } a) Ola 1 ** isto e um teste 2 b) Ola 2 ** isto e um teste 3 c) Ola 3 ** isto e um teste 3 d) Ola 0 ** isto e um teste 3 Exerc. v2. 2: No exercício anterior. • Compreenda os modificadores de visibilidade apresentados e as situações em que cada um deve ser utilizado • Utilize o operador de Auto-referenciação this Parte I – Questões Teóricas 1. VariavelDeClasse.n--.descricao = "isto e um teste". © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 88 . v1.print(v1.out.descricao + " "). v2.

Triângulo equilátero tem os 3 lados iguais. A classe ponto para representar as coordenadas e 2. 3: Crie um programa que determine a partir das coordenadas de 3 pontos. Sebenta da Disciplina de Introdução à Programação Exerc. 4. Um triângulo é rectângulo quando verifica a propriedade dada pelo teorema de Pitágoras: o quadrado da hipotenusa é igual à soma dos quadrados dos catetos. A classe triângulo para representar triângulos. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 89 . Triângulo escaleno tem os 3 lados diferentes. fornecidas pelo utilizador. Triângulo isóscele tem 2 lados iguais. Nota: 1. Deve também mostrar se se trata ou não de um triângulo rectângulo. 2. isósceles ou escaleno). o tipo de triângulo que estas representam (equilátero. 3. 3. Em separado terá a classe que contém o programa principal e faz uso das outras duas para cumprir os objectivos pretendidos. Deve implementar: 1.

Figura 44.1 . podendo necessitar de manipular vários valores. Programa Valor 1 Variável 1 Valor 2 Variável 2 Saída Valor 3 Variável 3 Figura 43.-1). 3). armazena estes valores em algumas variávei.. faz o respectivo processamento e envia o resultado para o exterior (fig. O programa deve processá-los “quase todos ao mesmo tempo” para produzir a saída desejada (fig. Nem sempre os programas manipulam tão poucos valores. Sebenta da Disciplina de Introdução à Programação 6.Motivação Um programa que manipule vários valores.-2).. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 90 . Valor 1 Programa Valor 2 Valor 3 variavel Saída Valor 4 Valor n . processamento de valores e saída. Estes podem ser lidos e processados um de cada vez(fig. Armazenamento. Tabelas 6. Manipulação de vários valores Imaginemos agora um programa que irá ler vários valores e imprimi-los pela ordem inversa.

Leitura de vários valores e sua visualização pela ordem inversa A alternativa para este tipo de situações é o uso de Tabelas.. Valor n Figura 46. 3 poderiamos armazenar os valores numa variável do tipo tabela e aceder aos valores pela ordem desejada (fig. Armazenamento de vários valores numa tabela.. Valor 1 Programa Valor 2 Valor 3 Saída Variável Valor 4 Tabela Valor 5 .. que não são mais do que uma lista de valores. Valor n Variável n Figura 45.. . Assim... Sebenta da Disciplina de Introdução à Programação Programa Valor 1 Variável 1 Valor 2 Variável 2 Valor 3 Variável 3 Saída Valor 4 Variável 4 Valor 5 Variável 5 . © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 91 .4). para o exemplo da fig.

© Escola Superior de Tecnologia de Setúbal 2005-2006 Página 92 . • uma vez criadas possuem um tamanho fixo. Sebenta da Disciplina de Introdução à Programação 6. Fazendo uma pequena revisão sobre as variáveis simples.2. As tabelas: • são um agregado de valores. declaração.2 . todos do mesmo tipo. que são manipulados por valor.Passos para utilizar uma tabela Os passos para utilizar uma tabela são três. • estão indexadas a partir de 0. No exemplo seguinte cria-se uma tabela com o nome tab.2. No exemplo que se segue cria-se uma referência para uma tabela de inteiros com qualquer dimensão. • o seu espaço é automaticamente reaproveitado quando deixam de estar referenciados. ou seja. sendo a mesma iniciada com null. tab null 2) Instanciação : Na instanciação de uma tabela é definida a capacidade da mesma. instanciação e referenciação: 1) Declaração : Na declaração de uma tabela cria-se uma referência para um determinado tipo de dados.Tabela Unidimensional 6. • são criadas quando da sua declaração. com uma capacidade para cinco inteiros. • armazenam tipos primitivos. int [] tab.2 . 6.1 . em tempo de execução. (2) int [ ] tab .Introdução Existem duas formas de declarar uma tabela em Java: (1) <tipo> <variável> [ ] (2) <tipo> [ ] <variável> Exemplos : (1) int tab [ ] . • são criadas em java dinamicamente. estas : • armazenam um só valor.

int tab [ ] = {1. tab[7] tab[1] tab[2] © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 93 .13. tab tab[0] tab[1] tab[2] tab[3] tab[4] • Uma tabela em java é sempre criada dinamicamente com o operador new • O índice dos elementos começa em 0 e termina em tamanho –1. // é criada uma tabela com // 8 elementos tab 1 1 2 3 5 8 13 34 tab[0] tab[3] ….. se se indicar o conteúdo.. ou seja.3. • Depois de instanciado podemos saber a sua dimensão consultando o atributo só de leitura length ( exp: tab. A instanciação (criação) de uma tabela pode ser feita no momento de declaração.34}.5.1.8. Caso se exceda a dimensão da tabela é gerada uma excepção. uma tabela de tamanho N é indexada de 0 a N-1. Sebenta da Disciplina de Introdução à Programação tab = new int[5] . tab[7] tab[1] tab[2] 3) Referenciação : tab[1] = 12. // o elemento com o índice 1 da tabela // passa a armazenar o valor 123 tab 1 12 2 3 5 8 13 34 tab[0] tab[3] ….2. • As tabelas de valores numéricos são inicializadas a zero.length).

podemos calcular a média e imprimir para o ecran o valor: System. que pode ser feita por duas formas : double total = pluv[0] + pluv[1] + pluv[2] + pluv[3] + pluv[4] + pluv[5] + pluv[6] + pluv[7] + pluv[8] + pluv[9] + pluv[10] + pluv[11] + pluv[12] + pluv[13] + pluv[14] + pluv[15] + pluv[16] + pluv[17].0). ……. Expressão x = valor / 2. if (tab[3] > 5.94.out. pluv [1] = 23. Exemplos de acesso aos elementos de uma tabela: Exemplo 1 Neste exemplo pretende-se calcular o valor médio da pluvisiosidade em 18 anos. //restante valores Depois efectua-se a soma dos valores. Sebenta da Disciplina de Introdução à Programação Exemplo do uso de tabela e variáveis simples Uso Variável Simples Tabela Atribuição valor = 10.out. Testa(tab[3]).println(“O valor média de pluviosidade é”+(total/pluv. ano ++) total = total + pluv[ano].nextDouble(). Comparação if (valor > 5. Para tal.6.println(valor). scanTeclado. Nota : relembre-se que o índice do vector começa em 0 e pode ir até length-1 Com o valor da soma efectuado.length)).0). ou double total = 0. Exemplo 2 © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 94 . tab[3] = 10.nextDouble().println(tab[3]). pluv [0] = 30. System. for ( int ano = 0. Entrada valor = tab[3]= scanTeclado. x = tab[3] / 2.6. Parâmetros Testa(valor). ano < pluv.length.0.55. Saída System.out. cria-se uma tabela que guarde 18 valores e preenchesse a tabela com os valores da pluvisiosidade: double [ ] pluv = new double [18].

out.println("Maximo:"+max). i++){ soma+=n1[i]. //Nota: na media é necessário fazer uma divisao de floats.println("Media:"+(float)soma/n1.println("i["+i+"]="+n1[i]). i++) System. Criação e preenchimento da tabela do exemplo 2.nextInt(). total for(int i=0. //Calcular máximo. int max=0. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 95 .out.println("Total:"+soma).out. Sebenta da Disciplina de Introdução à Programação O exemplo seguinte tem como objectivo pedir ao utilizador o valor de cinco inteiros. System. } //Mostrar resultados System. public class MaxTotal{ public static void main(String[] args) { int n1[] = new int[5]. if (max<n1[i]) max=n1[i].out.out. } Tabela criada com 5 Depois de uma Depois de duas Depois das elementos indexados iteração iterações cinco iterações de 0 a 4 do ciclo do ciclo do ciclo 0 1 1 1 1 3 3 2 10 11 3 4 2 índices Figura 47.i<5. } //Mostrar array for(int i=0.println(“Introduza um valor: “).length). a média e o valor máximo destes valores. int soma=0. i++) { n1[i]= scanTeclado.i<5. calcular a soma. System. System. imprimir no ecran os valores introduzidos.i<5. import Le. //Ler array for(int i=0.

Todas as tabelas de objectos são inicializadas a null.ArrayIndexOutOfBoundsException:19 At Teste. numAlunos=0. durante a execução do programa seria detectado um erro: n1 [5] = 4. } public Turma(int max) { tabelaAlunos = new Aluno[max]. deve-se criar uma classe Turma.4. Aluno [] tabelaAlunos . deve-se implementar os construtores da mesma. No caso da classe Turma serão definidos dois construtores. imaginemos que se pretendia gerir uma turma de alunos. numAlunos=0. com funcionalidades como inserir. No segundo construtor a dimensão da tabela de alunos será passada por argumento. //Lotação máxima } Quando se define uma classe. Na sequência da classe Aluno. procurar e apagar alunos. Em ambos os construtores a variável numAlunos é inicializada a zero por não existirem alunos inscritos no início.main(Test. define-se que a tabela de alunos terá como dimensão o valor da constante MAXIMO_ALUNOS. A solução seria criar uma tabela do tipo Aluno. Uma vez que se pretende gerir uma turma de alunos. } No primeiro construtor. do ponto 1. //acesso a um índice que não existe O erro detectado seria: Java. listar.Tabelas de Objectos As tabelas de objectos não são mais do que tabelas em que cada elemento é uma referência a um objecto de uma determinada classe. Caso se tentasse aceder a um elemento inexistente. no qual é criado e preenchido um array de cinco elementos.java) 6. private int numAlunos.lang. public Turma() { tabelaAlunos = new Aluno[MAXIMO_ALUNOS].2. que como atributo terá a tabela de alunos: public class Turma { private Aluno [ ] tabelaAlunos . © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 96 . // número de alunos inscritos na turma private final static int MAXIMO_ALUNOS=20. Sebenta da Disciplina de Introdução à Programação Atenção : acesso a elementos não existentes da tabela Considere o exemplo 2.3 .

ou seja.length && tabelaAlunos[i]!=null. return true. Sebenta da Disciplina de Introdução à Programação A funcionalidade inserir aluno na turma pode ser implementada da seguinte forma: public boolean insereAluno(Aluno a1) { if(tabelaAlunos.length>numAlunos) // testa se a tabela não está cheia { tabelaAlunos[numAlunos]=a1. lista os alunos inscritos na turma: public String listar( ) { String str="".i++) str= str+ i + " "+ tabelaAlunos[i]. //inserir na tabela tabelaAlunos[numAlunos++]=aluno. return str. é necessário verificar se a posição corrente tem ou não conteúdo. } Outra das funcionalidades requeridas é listar a informação contida na tabela. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 97 . // incrementa a variável num return true.i<tabelaAlunos. for(inti=0. turma). ano. } É de notar que quando se está a correr uma tabela de objectos.length>numAlunos) { Aluno aluno = new Aluno(nome.curso. // insere na tabela numAlunos++. } return false. tabelaAlunos[i]!=null é a expressão que verifica se a posição i da tabela de alunos é diferente de null. num. String curso. } return false. } Outra forma de implementar este método sem a passagem de um objecto do tipo Aluno seria: public boolean insereAluno(String nome. int ano. char turma) { if(tabelaAlunos.toString(). int num.

return str.toString(). public Aluno procuraAluno(String nome ) { for(int i=0.i<numAlunos. Como estamos perante variáveis do tipo String usa-se o método equals.i++) // verifica se o aluno na posição i tem o nome igual a nome if(this. O algoritmo deste método é dividido em duas partes: • Procura o índice da tabela onde se encontra o objecto a apagar.length && tabelaAlunos[i]!=null. Sebenta da Disciplina de Introdução à Programação Outra alternativa a este método: public String listar( ) { String str="".i++) // verifica se o aluno na posição i tem o numero igual a num if(this.i<tabelaAlunos. poderá ter duas implementações: • Procura pelo numero de aluno • Procura por nome de aluno public Aluno procuraAluno(int num ) { for(int i=0. for(inti=0.equals(str2) verifica se a str1 1 é igual à str2. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 98 .getNumero()==num) return tabelaAlunos[i]. str1. Como num é do tipo primitivo inteiro usa-se o operador ==. A funcionalidade de apagar aluno é mais complexa de implementar. } Na procura por número de aluno tem que se percorrer a tabela e para cada posição da mesma verificar se o número do aluno é igual ao num passado no argumento do método.getNome(). • Reconstrói a tabela a partir do índice encontrado. } Procurar um aluno na tabela.tabelaAlunos[i].i<tabelaAlunos.tabelaAlunos[i]. return null. return null.equals(nome)) return tabelaAlunos[i].length && tabelaAlunos[i]!=null.i++) str= str+ i + " "+ tabelaAlunos[i]. } Na procura por nome de aluno tem que se percorrer a tabela e para cada posição da mesma verificar se o nomedo aluno é igual ao nome passado no argumento do método.

out.println(tEIA.insereAluno("Ana". 1.println(tEIA.listar()). System.println(tEIA. 'A').listar()).println(a1).listar()).println(tEIA.j++) tabelaAlunos[j]=tabelaAlunos[j+1]. tEIA.out. 'A')."EI".insereAluno(aluno2). System.apagarAluno(2131).out.apagarAluno(2133). Aluno aluno2 = new Aluno("João". Aluno a1= tEIA. } Para testar o funcionamento dos métodos pode-se utilizar a seguinte classe com o método main: public class Principal { public static void main(String[] args) { Turma tEIA= new Turma(15). System. System. 2138. 2133. for(i=0.out.println(tEIA.out. System. } } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 99 . } if( flag) return false. Sebenta da Disciplina de Introdução à Programação public boolean apagarAluno(int num ) { boolean flag=true.listar()). 1. else { for(j=i-1. j<numAlunos-1. tEIA.listar()). tabelaAlunos[j]=null.i<numAlunos && flag.listar()).j.i++) if(tabelaAlunos[i]. tEIA. int i.insereAluno("Vitor". tEIA.out. System.getNumero()==num) { flag =false. 2137. 2131. System."EI". 'A'). 'A'). 1.insereAluno("Pedro".procuraAluno(2133)."EI".out. 1.apagarAluno(2138). tEIA. } return true. tEIA. tEIA."EI".println(tEIA.

// Inicialização ou Atribuição nome[0] = "Smith". © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 100 . indice ++) System.out.length. nome[2] = "Miller". Exemplos: Tabela de Strings No exemplo em seguida apresentado é declarada uma tabela de Strings que não é mais do que uma tabela em que cada elemento da tabela é uma referência a uma String. for (int indice = 0. nome[3] = "Luis". indice < nome. nome[1] = "Jones".out. // Saída System.println ("Resultado:"). Sebenta da Disciplina de Introdução à Programação O Output seria: tabelaAlunos [0]= Nome:João Numero :2133 curso : EI Ano1 tabelaAlunos [0]= Nome:João Numero :2133 curso : EI Ano1 tabelaAlunos [1]= Nome:Ana Numero :2131 curso : EI Ano1 tabelaAlunos [2]= Nome:Pedro Numero :2137 curso : EI Ano1 tabelaAlunos [3]= Nome:Vitor Numero :2138 curso : EI Ano1 Nome:João Numero :2133 curso : EI Ano1 tabelaAlunos [0]= Nome:Ana Numero :2131 curso : EI Ano1 tabelaAlunos [1]= Nome:Pedro Numero :2137 curso : EI Ano1 tabelaAlunos [2]= Nome:Vitor Numero :2138 curso : EI Ano1 tabelaAlunos [0]= Nome:Pedro Numero :2137 curso : EI Ano1 tabelaAlunos [1]= Nome:Vitor Numero :2138 curso : EI Ano1 tabelaAlunos [0]= Nome:Pedro Numero :2137 curso : EI Ano1 Em seguida serão apresentados mais exemplos sobre tabelas de objectos. nome[4] = "Gonzales". final int NUM_NOMES = 5.println (“nome[“ + indice + "]: " + nome[indice]). // Declaração e instanciação String[] nome = new String [NUM_NOMES ] .

println(“Tenho ”+ idade + “anos”).234. int pfI) { nome = pfN.out.apresentar(). String BI. idade = pfI. Sebenta da Disciplina de Introdução à Programação Tabela de Objectos da classe pessoa O código da classe pessoa. } public void apresentar() { System.567”.apresentar(). String pfC. public Pessoa (String pfN. apresenta-se em seguida: class Pessoa { String nome. BI = pfC. System. Pedro. Pedro = new Pessoa(“Pedro Martins”. System. Pessoa Nuno.println(“Meu nome é ” + nome).out.out. } } A classe seguinte testa a utilização da classe pessoa. Nuno = Pedro.“403. public class Teste { public static void main (String args[]) { Pessoa Pedro. } } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 101 .getBI()). } public String toString() { return (“nome=“+nome+”com “+idade+”anos”).println(“O BI de Pedro e “+Pedro. } public String getBI() { return BI. Nuno. 34). int idade.

pessoa ++) System. for (int pessoa = 0.println((pessoa + 1) + "ª Pessoa do Grupo: " + grupo[pessoa]. Exemplo gráfico dos resultados obtidos com o código anterior Tabela dinâmica No exemplo apresentado em seguida será criada uma tabela dinâmica.out. "403234567". grupo[3] = new Pessoa("Joaquim Feliz". int i=1. import Le. } } grupo[0] grupo[1] grupo[2] grupo[3] Pedro António João Silva Joaquim Sousa Pereira Feliz Figura 48. "233544325". public static void main(String args[]) { //Declaração de uma tabela de inteiros com // dimensão ainda indefinida int tab[ ]={}. int soma=0. grupo[2] = new Pessoa("João Silva". Sebenta da Disciplina de Introdução à Programação Em seguida apresenta-se o código onde se cria uma tabela de objectos da classe pessoa.toString ).37). int max=0. lida uma lista de números inteiros terminada por 0 e depois com os valores lildos calculada a média e o valor máximo. //Inicialização dos elementos da tabela (Atribuição) grupo[0] = new Pessoa("Pedro Sousa".34). "763234567". public class TabelaDeObjectos { public static void main(String[] args) { //Declaração e Instanciação da tabela Pessoa[ ] grupo = new Pessoa [4].println("Conteúdos de cada elemento da tabela:"). pessoa < 4. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 102 . "213456567".20). grupo[1] = new Pessoa("António Pereira".40). que é uma tabela em que cada elemento é uma referência a um objecto da classe pessoa. //Saída System.out.

out. } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 103 . Sebenta da Disciplina de Introdução à Programação //Ler 1º valor System.nextInt().nextInt(). System. System.j<tab.length. i++) { soma+ = tab[i].out. i++) System.length).print(“Insira o ” + j + ”º inteiro:> ”). //copiar valores for(int j=0.out.println("Media:"+(float)soma/n1. i<tab. //Nota: na media é necessário fazer uma divisao de floats. } //Mostrar tabela for(i=0. //inserir novo valor tabTemp[tabTemp. //colocar a tabela temporária na definitiva tab = tabTemp. while (n!=0) { //criar tabela temporária int tabTemp[]=new int[tab.out.println("Total:"+soma).length-1]=n. System.println(“tab[“ + i + "]="+ tab[i]). n = scanTeclado. } //Mostrar resultados System.print(“Insira o 1º inteiro:> ”).length+1].out. if (max < tab[i]) max = tab[i]. i<tab. //Calcular o valor máximo e a soma total for(i=0.println("Maximo:"+max). int n = scanTeclado.j++) tabTemp[j]=tab[j].out.length.length.

} public int obterTelefone() { return telefone. int telefone. //Construtores public ListaTelefonica(){ contactos = new Contacto[MAXCONTACTOS]. private int nContactos=0. cria-se a classe Contacto. //Construtores public Contacto(String nomeContacto. private Contacto contactos []. Sebenta da Disciplina de Introdução à Programação Lista Telefónica No exemplo seguinte pretende-se criar uma lista telefónica. } } Em seguida veremos a classe Lista telefónica na qual é manipulado uma tabela de objectos do tipo Contacto: public class ListaTelefonica { //Atributos private static final int MAXCONTACTOS= 20. cujos atributos são o nome e o telefone da pessoa: public class Contacto { //Atributos String nome. Para tal." + telefone. } //Métodos public String mostrarContacto() { return nome + " . } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 104 . } public String obterNome() { return nome. int telefoneContacto) { nome=nomeContacto. telefone=telefoneContacto.

println("Introduza o nome:").mostrarContacto()). Contacto c = new Contacto(nome.println("O número não se encontra na lista. } public void ordenar(){ quickSort(0. else System.compareToIgnoreCase(pivot) > 0) j--. String pivot = contactos[(pri + ult)/2].next().out.mostrarContacto()). int telefone.obterNome(). int ult) { int i = pri.out. } private void quickSort( int pri.out.compareToIgnoreCase(pivot) < 0) i++.println("Qual o telefone:"). int i=0.println(contactos[i]. nContactos-1). while(i<nContactos && contactos[i].obterTelefone()!=telefone) i++. } public void procurar(){ System. contactos[nContactos]=c.println(contactos[i].telefone). } public void mostrar(){ for ( int i=0. if (i!=nContactos) System.nextInt(). telefone= scanTeclado. System. nome= scanTeclado.obterNome().out."). nContactos++. Sebenta da Disciplina de Introdução à Programação //Métodos public void adicionar() { String nome.out. do { while (contactos[i]. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 105 .nextInt(). i++) System. if (pri > ult) return. while (contactos[j].out. int telefone= scanTeclado. i<nContactos. int j = ult.println("Introduza o telefone:"). System.obterNome().

Sebenta da Disciplina de Introdução à Programação

if (i <= j)
trocaContactos(i++, j--);
}
while (i <= j) ;
quickSort(pri, j);
quickSort(i, ult);
}

private void trocaContactos(int i, int j){
Contacto tmp = contactos[i];
contactos[i] = contactos[j];
contactos[j] = tmp;
}
}

public class ExemploListaTelefonica {

public static void main(String[] args)
{
ListaTelefonica listaTel = new ListaTelefonica();

int seleccao;
do
{
System.out.println("Organizer");
System.out.println("");
System.out.println("1 - Adicionar");
System.out.println("2 - Mostrar");
System.out.println("3 - Procurar");
System.out.println("4 - Ordenar");
System.out.println("5 - Sair");
System.out.println("_______________________");
System.out.println("Qual a sua escolha?");
seleccao = scanTeclado.nextInt();

switch(seleccao){
case 1:
listaTel.adicionar();
break;
case 2:
listaTel.mostrar();
break;
case 3:
listaTel.procurar();
break;
case 4:
listaTel.ordenar();
break;
case 5:

© Escola Superior de Tecnologia de Setúbal 2005-2006 Página 106

Sebenta da Disciplina de Introdução à Programação

System.out.println("Adeus.");
break;
default:
System.out.println("Opção errada. Tente de Novo.");
break;
}
}
while(seleccao != 5);
}
}

6.4 - Passagem de tabelas como parâmetros de métodos
Uma tabela pode ser passada como parâmetro a um método. O que é passado como parâmetro (por valor) é a
referência da tabela, o que significa a alteraração de um elemento da tabela dentro do método, altera a tabela original.

Também é possível passar como parâmetro um elemento de uma tabela, desde que se sigam as regras referentes ao
seu tipo.

É possível passar como parâmetro um elemento de uma tabela, desde que se sigam as regras referentes ao seu tipo.

Exemplo:

public class programa {

public static void main(String args[]) {
int [] array = new int[2];

array[0]=12;
array[1]=10;

for(int i=0;i<array.length;i++)
System.out.println(array[i]);

metodo_1(array);

for(int i=0;i<array.length;i++)
System.out.println(array[i]);

metodo_2(array[1]);

for(int i=0;i<array.length;i++)
System.out.println(array[i]);
}

public static void metodo_1(int [] varray) {
for(int i=0;i<array.length;i++)
array[i]=array[i]+1;
}

public static void metodo_2(int var) {

© Escola Superior de Tecnologia de Setúbal 2005-2006 Página 107

Sebenta da Disciplina de Introdução à Programação

System.out.println(“O valor recebido é :”+var);
}
}

O output do código atrás apresentado, à luz dos conceitos introduzidos é:
12
10
13
11
O valor recebido é 11.
13
11

6.5 - Tabela Multidimensional
Uma tabela uni-dimensional representa uma lista de valores enquanto que uma tabela multidimensional representa
uma matriz, com linhas e colunas.

Cada elemento de uma tabela multidimensional é referenciado usando dois índices.
Em Java, uma tabela multidimensional é uma tabela de tabelas, ou seja é uma tabela uni-dimensional em que cada
elemento é uma referência para um objecto do tipo tabela.

Declaração:

<tipo> [ ] [ ] <variável>

Exemplo

int [ ] [ ] tab;

O código acima declara tab como uma tabela bidimensional de inteiros ou como uma tabela de tabelas, em que
apenas se cria uma referência.

A inicialização é que cria a tabela com os comprimentos respectivos:

1) tab = new int [2] [3];
ou
2) tab [][]={1,2,3} {4,5,6};

tab tab[0][0] tab[0][2]

tab[0] 1 2 3

tab[1] 4 5 6

tab[1][2]

Para percorrer a tabela usam-se ciclos for encadeados.

© Escola Superior de Tecnologia de Setúbal 2005-2006 Página 108

out.print("tab[" + i + "][" + j + "] = " + tab[i][j]). } } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 109 . k < a3[i][j]. 6 }}. Sebenta da Disciplina de Introdução à Programação Exemplo public class Matriz { public static void main(string args[]) { int tab[][] = {{ 1.length. Exemplo O exemplo seguinte mostra uma matriz 3D de vectores de comprimento variado. for(int j = 0. i++) for(int j = 0. Integer a3[][][] = new Integer[gerador.out. k < a3[i][j]. k++) System. for(int i = 0. sendo portanto o número de dimensões da matriz e o tipo dos elementos são definidos. } } for(int i = 0. i++) { a3[i] = new Integer[gerador. O número de elementos em cada dimensão pode variar e o conteúdo dos elementos de uma tabela pode ser de quaisquer objectos ou tipos primitivos. public class Ex { public static void main(string args[]) { Random gerador = new Random(). j++) System.print("a3["+i+"]["+j+"]["+k+"] = " + a3[i][j][k]). for(int i = 0. 5.nextInt(7)][]. j++) { a3[i][j] = new Integer[gerador.nextInt(7)][][]. 2. i++) for(int j = 0.nextInt(5)]. } } O Java é uma linguagem fortemente tipada.length.length. j < tab[i].length. k++) a3[i][j][k] = new Integer(i*j+k). i < a3. for(int k = 0.length. { 4. j < a3[i]. 3 }. i < a3.length.length. j < a3[i].length. i < tab. j++) for(int k = 0.

6. Exemplo Neste exemplo será criado um objecto da classe Vector que armazenará nomes.util e funciona de forma idêntica a uma tabela. Um objecto do tipo Vector gere uma lista de referências para a classe Object. Object elementAt (int index) Retorna o Objecto no indice especificado boolean isEmpty ( ) Retorna true se o vector estiver vazio int size ( ) Retorna o número de elementos do vector Nota: Para mais informações sobre os métodos disponibilizados por esta classe. Outra diferença consiste no facto de um objecto do tipo vector não ser declarado para guardar um tipo de valor.Alguns métodos da classe Vector Método Descrição Vector ( ) Cria um vector vazio void addElement (Object obj) Adiciona o objecto especificado ao fim do vector void insertelementAt (Object obj. verificar que elemento está num determinado índice.6.6. Serão depois aplicadas algumas operações ao vector.Introdução A classe Vector faz parte do package java.Classe Vector 6. remover. int index) Adiciona o elemento no índice especificado Object remove ( int index) Remove um objecto do índice especificado e retorna-o boolean removeElement (Object obj) Remove a primeira ocorrência do objecto especificado. Sebenta da Disciplina de Introdução à Programação 6. permitindo a armazenamento de valores e a referência a estes através de um índice. void removeElementAt(int index) Remove um objecto do índice especificado void clear ( ) Remove todos os elementos do vector boolean contains (Object obj) Retorna true se o objecto está no vector int indexOf (Object obj) Retorna o índice do objecto especificado. consultar a documentação do Java.1 . Retorna -1 caso o objecto não exista. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 110 . permitindo assim guardar qualquer tipo de valor. A grande diferença entre uma tabela e um objecto do tipo Vector é que este pode crescer e diminuir dinamicamente em tamanho. enquanto que uma tabela tem sempre um tamanho fixo. como inserir.2 .6 .

addElement(“Daniel”). nomes. Nuno.Exercícios Práticos Exerc. Daniel Ricardo. nomes. A assinatura do método é a que se segue: static double produto(int [ ] x) Exerc.1 – Escreva um programa que preencha uma tabela com os valores inteiros gerados aleatoriamente e imprima todos os valores da tabela.elementAt(1)).2).Implemente um método que retorna o menor valor de uma tabela. A assinatura do método é a que se segue: static double menorValor(double [ ] x) © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 111 . nomes.size()).addElement(“Nuno”).addElement(“João”).addElement(“Ricardo”). System. nomes.7 .insertAt(“Carlos”.out. Sebenta da Disciplina de Introdução à Programação public class Nomes { public static void main ( String [] args) { Vector nomes = new Vector( ). nomes. Daniel No índice 1: Nuno Tamanho do vector 4 6. João.out. System.println(nomes). } } Resultado de saída do exemplo Ricardo. Acrescente depois as seguintes funcionalidades ao seu programa: • Indicar quantos valores negativos estão guardados na tabela • Imprimir os valores positivos da tabela • Indicar o maior valor da tabela • Substituir todos os valores divisíveis por 3 pelo valor zero • Indicar a posição do menor valor da tabela Exerc.println(“Tamanho do vector “ + nomes.println(“No índice 1: “ + nomes. System.Implemente um método que retorna o produto dos elementos de uma tabela. nomes.println(nomes).out.3 . System.2 .out.removeElement(“João”). Nuno.

5 1 7. Exerc.4 8.1 2.9 .2 7.4 2 6.5 .1 2 2.Escrever um método que receba um número e uma tabela e devolva a posição na tabela onde este número ocorra ou o valor -1 no caso do número não existir na tabela.2 4 8. Exemplo: Para A = ( 1 3 6 7 8 ).8 . Exerc.Escrever um programa que converta uma string numa tabela de caracteres.7 . Exemplo: n = 10 Sequência: 3.13 .Dada uma sequência de n números reais.5 3.Escrever um programa que. fazer um programa que determine os números que compõem a sequência e a frequência de tais números na sequência dada. para um dada tabela de inteiros A. o programa deve construir P = ( 3 5 ). A assinatura do método é a que se segue: static int indiceValor(int [ ] tabela.10 .Escrever um método (e um programa que exercite tal método) que determine se os elementos de uma tabela encontram-se em ordem decrescente ou não. determine o número de ocorrências de cada face na sequência analisada.2 8. Exerc.11 . Exerc. Exerc.2 6. passada como parâmetro. retorne a diferença entre os valores máximo e mínimo da sequência. Exerc.Escrever um método que retire todas ocorrências de um caracter carC de uma string.4 .Escrever um método que receba duas tabelas e retorne true se as tabelas são iguais.3 1 Exerc. A assinatura do método é a que se segue: static String remove(String s. Em seguida altere o programa anterior para indicar todas as posições da matriz em que se encontra tal valor máximo.2 Saída: Num Freq 3. dada uma sequência de n valores inteiros (gerados aleatoriamente) que representam o resultado de n lançamentos de um dado. construa uma tabela P formada pelos índices dos elementos pares de A.12.6 . Sebenta da Disciplina de Introdução à Programação Exerc. Exerc. char carC ) Exerc.Escrever um método que.14 . Exerc.15 .Escrever um método que inverta a ordem dos elementos de uma tabela de inteiros.1 3.Escrever um programa que determine o maior valor em uma matriz de valores inteiros com n>0 linhas e m>0 colunas. dada uma sequência de n valores inteiros. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 112 .3 7.Escrever um método que devolva a posição da última ocorrência do valor máximo de uma tabela de valores do tipo double.Escrever um programa que. int valor) Exerc.4 3.

17 .Escrever um programa que inicialmente lê um número inteiro N. Caso contrário. double[] y) Exerc. Exerc. Se o valor introduzido for menor que 2 (dois) finalizar o programa. mostrar se a matriz possui algum valor repetido.Defina uma classe WebSite caracterizada pelo nome.Implemente um método que retorne o cálculo do produto externo entre duas matrizes. endereço e lista de temas que se podem encontrar no mesmo. A matriz resultante calcula-se da seguinte forma p[i][j]=x[i]*y[j].16 . Implemente as seguintes funcionalidades a esta classe: • Determinação de quantos temas possui o website • Verificar se um determinado tema existe no website • Adicionar um tema • Remover um tema Elabore uma classe CatalogoWeb que implementa um arquivo sobre webSites e cujas funcionalidades são: • Determinação do número total de websites do catálogo • Listar os Websites que tratam um determinado tema T • Remover um website Exerc.3. 20 – Construa uma classe estática que tem como objectivo conter métodos utilitários para a manipulação de tabelas. Esses métodos são os já criados nos exercícios 2. Em seguida lê um valor para cada posição da matriz e. no final.8 e 10. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 113 . 18 . onde x e y são as tabelas de entrada. Sebenta da Disciplina de Introdução à Programação Exerc. A assinatura do método é: static double[][] productoExterno(double[] x. cria dinamicamente uma matriz de inteiros NxN.

out. for (int i=0. passada como parâmetro. Sebenta da Disciplina de Introdução à Programação 7. class Tabela { public static void preenche(int tabela[]){ Random random = new Random(). • A procura binária. O código da classe é em seguida apresentado: import java. Vamos para tal fazer uso de uma classe (Tabela) que possui um método (preenche) que preenche uma tabela. Algoritmos de Procura/Pesquisa 7.Introdução A procura de informação é uma actividade quotidiana: procuramos números em listas telefónicas. palavras em dicionários.out.2.1 . } public static void imprime(int tabela[]){ for (int i=0. i < tabela. • Repetir o processo até encontrar o elemento ou atingir o fim da tabela. Ao longo deste capítulo vamos utilizar uma tabela preenchida. } } 7.length. etc. • Comparar sucessivamente o elemento procurado com o elemento da tabela. Estudaremos em seguida dois métodos para procurar um elemento numa tabela: • A procura sequencial.1 . © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 114 .Random. System. i++) System. i < tabela.util. com valores inteiros gerados aleatoriamente entre 0 e 100. A procura de informação é frequentemente executada em tabelas.nextInt(100).println().Simples Uma forma simples de procurar consiste em: • Começar no inicio da tabela.println(" "+i+":"+ tabela[i]+".length. i++) tabela[i] = random.Procura Sequencial 7. Como a tabela é percorrida sequencialmente. o algoritmo é denominado por procura sequencial.2 . "). No exemplo seguinte pretende-se saber qual a posição que o valor 75 (se existir) ocupa na tabela de números.

101)).out.out. Sebenta da Disciplina de Introdução à Programação 0 1 2 3 4 5 Índice 10 20 75 9 4 3 Posição 0 Compara-se 75 com 10 → São diferentes Incremento a posição Posição 1 Compara-se 75 com 20 → São diferentes Incremento a posição Posição 2 Compara-se 75 com 75 → São iguais Parar a procura O valor procurado é achado e ocupa a terceira posição da tabela. Tabela. public class ProcuraSequencial{ public static int procura (int tab[]. caso contrário retorna -1.println("Resultado:"+procura(tabela. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 115 . } public static void main(String[] args){ int tabela[] = new int[100].out. Note-se que no ciclo correspondente à procura propriamente dita. } } O método procura retorna o índice do valor na tabela se encontrar o valor. if ( i != tab.println("Resultado:"+procura(tabela. // retorna indice. int valor) { int i = 0.length) return(i). System. else return(-1).preenche(tabela).out.length && tab[i] != valor ) i++.println("Resultado:"+procura(tabela.33)). O próximo exemplo utiliza um programa que preenche uma tabela com números gerados aleatoriamente (entre 0 e 100) e permite.1)). System. System.67).println("Resultado:"+procura(tabela. em seguida. System. while (i < tab. procurar números que foram inseridos.

out. System. Sebenta da Disciplina de Introdução à Programação while (i < tab. então o valor procurado não existe na tabela. ainda antes da procura.1)).out. 7. Tabela. Neste caso trata-se de inserir o valor procurado a seguir ao último elemento da tabela.println("Resultado:"+procura(tab.102). System. procurar números que foram inseridos. //SENTINELA while (tab[ i ] != valor ) i++. System.33)). A primeira operação a efectuar.println("Resultado:"+procura(tab.Com Sentinela Uma técnica utilizada para prescindir do segundo teste consiste em utilizar um denominado valor sentinela. int valor){ int i = 0.out. else return(-1).length && tab[ i ] != valor ) { tem de se efectuar continuamente dois testes: • verificar se o valor desejado foi encontrado e • verificar se o fim da tabela foi atingido.length-1] = valor. } public static void main(String[] args){ int tab[] = new int[101].length-1) return(i).67)).println("Resultado:"+procura(tab. System. Se no fim da procura o valor encontrado for o sentinela. Embora a primeira verificação seja essencial a segunda seria desnecessária se pudesse garantir que o valor a procurar se encontrava na tabela.preenche(tabela).println("Resultado:"+procura(tab. em seguida. No exemplo seguinte procede-se a implementação da procura sequencial com sentinela. Um valor sentinela é um valor especial que inserimos na tabela para garantir que a procura tem sucesso. utilizando um programa que preenche uma tabela com números gerados aleatoriamente (entre 0 e 100) e permite.out.2. } } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 116 .2 . public class ProcuraSequencialSentinela { public static int procura(int tab[]. tab[tab. A utilização de um valor sentinela exige a existência de uma posição adicional na tabela para armazenar o valor sentinela. if ( i != tab. é a inserção do valor sentinela no final da tabela.

i < tabela.length . i++) tabela[i] = i. int meio = alto/2. Consideramos último o elemento da 1ª metade da tabela. 2. podemos garantir que o procurado não se encontra na 1ª metade da tabela. A procura binária é uma alternativa mais eficaz. em seguida. procurar os números que foram inseridos. Isto acontece sempre que o elemento que estamos a procurar não se encontra na tabela. Repetimos então processo para a 1ª metade da tabela. } public static void main(String[] args) { int tabela[] = new int[100 for (int i=0.1. int valor) { boolean achou = false. 4. 6. Encontramos o meio da tabela. public class ProcuraBinaria { public static int procuraBinaria(int tab[]. } return((achou ) ? meio : -1). Se o elemento procurado é menor do que o último o elemento da 1ª metade da tabela. int baixo = 0. mas exige que os elementos sobre os quais a procura está a ser efectuada se encontrem ordenados. Note-se que em cada passo a procura binária reduz o número de elementos a considerar para metade O próximo exemplo utiliza um programa que lê 100 números e permite. 8.length. while (!achou && alto >= baixo ) { if (valor == tab[meio ]) achou = true. 7. Repetimos então o processo para a 2ª metade da tabela. 5.1. Se o elemento no meio da tabela for igual ao procurado a procura termina. Sebenta da Disciplina de Introdução à Programação 7. else baixo = meio + 1. podemos garantir que o procurado não se encontra na 2ª metade da tabela. meio = (alto + baixo )/2. mas pode exigir a inspecção de todos os elementos da tabela. else if (valor < tab[meio ]) alto = meio . Se o elemento procurado é maior do que o último o elemento da 1ª metade da tabela. O algoritmo é o seguinte: 1. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 117 .Procura Binária A procura sequencial é muito simples.3 . 3. int alto = tab.

© Escola Superior de Tecnologia de Setúbal 2005-2006 Página 118 .out.println("Resultado:"+procuraBinaria (tabela.out. System. System.1)).out. System.67)).println("Resultado:"+procuraBinaria (tabela.println("Resultado:"+procuraBinaria (tabela.33)). } } Exemplo (Pesquisa de um valor inexistente na tabela) baixo x: 2 1ª iteração v: 1 3 3 5 7 8 9 (>x) baixo meio alto Valor a Procurar 2ª iteração 1 3 3 5 7 8 9 (>x) baixo meio alto 3ª iteração 1 3 3 5 7 8 9 (<x) baixo alto 4ª iteração 1 3 3 5 7 8 9 O valor 2 não existe na tabela Figura 49.println("Resultado:"+procuraBinaria (tabela.101)).out. Sebenta da Disciplina de Introdução à Programação System. Pesquisa binária de um valor inexistente na tabela.

} return((achou ) ? meio : -1). © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 119 . } Exemplo (Pesquisa de um valor existente na tabela) baixo meio alto x: 1 1ª iteração v: 1 3 3 5 7 8 9 (>x) baixo meio alto Valor a Procurar 2ª iteração 1 3 3 5 7 8 9 (>x) baixo meio alto 3ª iteração 1 3 3 5 7 8 9 (<x) O valor 1 existe na tabela Figura 50. int valor) { boolean achou = false. Sebenta da Disciplina de Introdução à Programação public static int procuraBinaria (int tab[].1. Utilize o algoritmo de procura sequencial. int meio = alto/2.1. int baixo = 0. while (!achou && alto >= baixo ){ if (valor == tab[meio ]) achou = true.length .Exercícios práticos Exerc.Implemente o método máximo que retorna o maior valor dos elementos da tabela x. else baixo = meio + 1. else if (valor < tab[meio ]) alto = meio .1 . int alto = tab. Pesquisa binária de um valor existente na tabela 7. meio = (alto + baixo )/2.4 .

int x. A assinatura do método é public static int minimo(float[ ] tabF).3 . Qual foi a diferença entre a temperatura mais baixa e a temperatura mais alta. Nota: a lista é terminada com a palavra “ * ‘” A assinatura do método é: public static boolean procuraPessoa(String[ ] v) © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 120 . Exerc. int s) Exerc. que tem como critério de paragem o valor de s. Em que dia ocorreu a temperatura mais elevada 3.Implemente o método procuraCar que retorna o índice da primeira ocorrência do caracter c1 na tabela tabCar. Exerc. É necessário implementar um método que dado o nome de uma pessoa.Implemente o método procuraFloat que procura na tabela v. Utilize a procura binária na implementação desta função. mantém uma lista de todos os trabalhadores que num determinado momento se encontram dentro da empresa. Utilize o método de procura binária. car c1) Exerc.2 .Implemente o método mínimo que retorna o índice do elemento de menor valor da tabela tabF.6 . A assinatura do método é: public static int procuraCar(car[ ] tabCar. se esta contem o elemento x. Sebenta da Disciplina de Introdução à Programação Exerc.Temos uma tabela com as temperaturas médias ao longo dos dias de mês. Queremos saber para um determinado mês: 1.4 . ele nos valide se esta pessoa se encontra dentro da empresa ou não. Qual foi a temperatura mais baixa 2. assinatura do método é public static int procuraInteiro(int[] v. Caso a procura seja realizada com sucesso retorna o índice do elemento.Um sistema de controlo de presenças ligado ao sistema de marcação de ponto. senão retorna –1.5 .

println(). sobre uma tabela: • Preenchimento de uma tabela com valores inteiros. i < tabela.1 . vamos supor que pretendemos ordenar uma sequência de inteiros com um máximo de 100 elementos.util. i < tabela. } // O método main vai variar para cada implementação } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 121 . Imagine que teria de procurar o número de telefone de um amigo numa lista telefónica que não estivesse ordenada alfabeticamente.Random. } //(2) troca as posições de dois elementos da tabela public static void troca(int tabela[]. • Impressão dos elementos de uma tabela. import java. } //(3) Imprime a tabela public static void imprime(int tabela[]) { for (int i=0. • Troca de elementos de uma tabela. int y){ int tmp. "). int x.length. for (int i=0. Em programação. não ordenados.out. System. Sebenta da Disciplina de Introdução à Programação 8. i++) tabela[i] = random. i++) System.nextInt(100). gerados aleatoriamente. Nos algoritmos de ordenação que serão em seguida introduzidos. vamos apresentar de seguida uma classe (Tabela) que permite realizar as seguintes funções. Ordenamos as coisas para facilitar a procura e não por sermos naturalmente arrumados. tmp = tabela[x]. Algoritmos de Ordenação 8.length. tabela[x] = tabela[y].println(" "+i+": "+ tabela[i]+" . Com o objectivo de separar algumas operações que se repetem ao longo dos exemplos de ordenação. class Tabela { //(1) preenche uma tabela public static void preenche(int tabela[]) { Random random = new Random().Introdução Um conjunto de elementos é normalmente ordenado para facilitar a procura. Seria caótico certamente.out. tabela[y] = tmp. a utilização de tabelas ordenadas permite escrever algoritmos de procura mais eficientes.

2 . De um modo geral uma única passagem pelo conjunto de elementos não ordena a tabela. Sebenta da Disciplina de Introdução à Programação 8. Consideremos a seguinte tabela.BubbleSort Este algoritmo consiste em: • Percorrer os elementos a ordenar. Note que a tabela encontra-se ordenada quando se efectua uma passagem completa em que nenhum par de elementos trocou de posição. • Até que se tenha efectuado uma passagem completa em que não haja nenhuma troca de posições. onde se aplicará o algoritmo BubbleSort: 0 1 2 3 4 5 Índice 4 8 17 3 11 2 Veremos a evolução da posição dos elementos ao longo das passagens e da variável trocou que permite saber se ao longo da passagem houve trocas de posição. onde n é o numero de elementos a serem ordenados. Primeira passagem trocou = false 4 8 17 3 11 2 4 8 17 3 11 2 4 8 3 17 11 2 (trocou=true) 4 8 3 11 17 2 (trocou=true) 4 8 3 11 2 17 (trocou=true) Segunda passagem trocou = false 4 8 3 11 2 17 4 3 8 11 2 17 (trocou=true) 4 3 8 11 2 17 4 3 8 2 11 17 (trocou=true) 4 3 8 2 11 17 Terceira passagem trocou = false 3 4 8 2 11 17 (trocou=true) 3 4 8 2 11 17 3 4 2 8 11 17 (trocou=true) 3 4 2 8 11 17 3 4 2 8 11 17 Quarta passagem trocou = false 3 4 2 8 11 17 © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 122 . comparando elementos adjacentes e trocando os pares de elementos que se encontram fora de ordem. O tempo de execução é proporcional a n2.

//ordena tabela Tabela. do { houveTroca = false. } public static void main(String[] args) { int tabela[] = new int[100]. //preenche tabela Tabela.length-1. } }while (houveTroca).preenche(tabela). for (int j = 0.troca(tabela. j.imprime(tabela). Sebenta da Disciplina de Introdução à Programação 3 2 4 8 11 17 (trocou=true) 3 2 4 8 11 17 3 2 4 8 11 17 3 2 4 8 11 17 Quinta passagem trocou = false 2 3 4 8 11 17 (trocou=true) 2 3 4 8 11 17 2 3 4 8 11 17 2 3 4 8 11 17 2 3 4 8 11 17 Sexta passagem trocou = false 2 3 4 8 11 17 2 3 4 8 11 17 2 3 4 8 11 17 2 3 4 8 11 17 2 3 4 8 11 17 trocou == false – Termina! O código da implementação do algoritmos BubbleSort é apresentado em seguida: public class OrdenacaoBubbleSort { public static void bubbleSort(int tabela[ ] ) { boolean houveTroca. //imprime tabela depois de ordenada } } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 123 . j < tabela. //imprime tabela antes da ordenação bubbleSort(tabela). houveTroca = true.imprime(tabela). Tabela. j+1). j++) if (tabela[j] > tabela[j+1]){ Tabela.

não elementos adjacentes. Passagem 1 Intervalo=3 trocou=False 3 8 17 4 11 2 (trocou=true) 3 8 17 4 11 2 3 8 2 4 11 17 (trocou=true) Passagem 2 Intervalo=3 trocou=False 3 8 2 4 11 17 3 8 2 4 11 17 3 8 2 4 11 17 Passagem 3 Intervalo=1 trocou=False 3 8 2 4 11 17 3 2 8 4 11 17 (trocou=true) 3 2 4 8 11 17 (trocou=true) 3 2 4 8 11 17 3 2 4 8 11 17 Passagem 4 © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 124 . com o intervalo inicial.3 . Como intervalo inicial considera-se metade do número de elementos a ordenar. do tipo BubbleSort. da variável trocou que permite saber se ao longo da passagem houve trocas de posição e da variável intervalo que define a distância entre elementos comparados.ShellSort A ordenação ShellSort é uma variante da ordenação BubbleSort e consiste em comparar e trocar. Este processo repete-se até que o intervalo seja 1 (correspondente a uma ordenação por BubbleSort). Note que a ordenação ShellSort é mais eficiente (mais rápida) do que a ordenação BubbleSort porque as primeiras passagens consideram apenas um subconjunto dos elementos a ordenar e as últimas passagens já os encontram parcialmente ordenados. Sebenta da Disciplina de Introdução à Programação 8. esse intervalo é dividido ao meio e o processo repete-se para o novo intervalo. Após uma ordenação completa. Consideremos a tabela que foi usada no exemplo do Bubblesort: 0 1 2 3 4 5 Índice 4 8 17 3 11 2 Vejamos a evolução da posição dos elementos ao longo das passagens. mas sim elementos separados por um certo intervalo.

j < tabela.troca(tabela.length-intervalo. //imprime tabela antes da ordenação shell(tabela). Sebenta da Disciplina de Introdução à Programação Intervalo=1 trocou=False 2 3 4 8 11 17 (trocou=true) 2 3 4 8 11 17 2 3 4 8 11 17 2 3 4 8 11 17 2 3 4 8 11 17 Passagem 5 Intervalo=1 trocou=False 2 3 4 8 11 17 2 3 4 8 11 17 2 3 4 8 11 17 2 3 4 8 11 17 2 3 4 8 11 17 O código da implementação do algoritmo ShellSort é apresentado em seguida: public class OrdenacaoShell { public static void shell (int tabela[ ] ) { boolean nenhumaTroca. Tabela. } public static void main(String[] args){ int tabela[] = new int[100]. nenhumaTroca = false. } }while (!nenhumaTroca). //ordena tabela © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 125 . for (int j = 0.preenche(tabela). //preenche tabela Tabela. intervalo = tabela.length / 2.imprime(tabela). j+intervalo). j++) if (tabela[j] > tabela[j+intervalo]) { Tabela. }while ( intervalo > 0). do { do { nenhumaTroca = true. j. int intervalo. intervalo = intervalo / 2.

//imprime tabela depois de ordenada } } 8. for (i = 0. colocar um elemento na sua posição correcta: o Na 1ª passagem coloca-se o menor elemento na sua posição correcta. for (j = i+1. o Na 2ª passagem coloca-se o segundo menor. j < numbers. j++) { if (numbers[j] < numbers[min]) min = j. i < numbers.length-1. o E assim sucessivamente. i++) { min = i. int min. temp.imprime(tabela). Consideremos novamente a mesma tabela: 0 1 2 3 4 5 Índice 4 8 17 3 11 2 Vejamos a evolução da posição dos elementos ao longo das passagens: Primeira passagem (4 8 17 3 11 2) 2 8 17 3 11 4 Segunda passagem (2 8 17 3 11 4) 2 3 17 8 11 4 Terceira passagem (2 3 17 8 11 4) 2 3 4 8 11 17 Quarta passagem (2 3 4 8 11 17) 2 3 4 8 11 17 O código da implementação do algoritmo é apresentado em seguida: public class OrdenacaoSeleccao { void selectionSort(int numbers[]) { int i.length. j. Sebenta da Disciplina de Introdução à Programação Tabela. } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 126 .Ordenação por selecção A ordenação por selecção consiste em percorrer os elementos a ordenar e.4 . em cada passagem.

5 . min). v[n-1] (vazio se i>n-1) O tempo de execução é proporcional a © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 127 . //imprime tabela antes da ordenação selectionSort(tabela). Tabela. • Enquanto i ≤ j.preenche(tabela).. ƒ O grupo direito é composto pelos elementos maiores que o elemento pivot. . //preenche tabela Tabela.. } } public static void main(String[] args) { int tabela[] = new int[100]. • Seja x o elemento pivot contido no meio da tabela (x = v[n/2]). decrementar j ƒ Se i ≤ j.. v[j] (vazio se j<0) • O grupo direito (com valores ≥ x) é v[i].imprime(tabela). i.. Sebenta da Disciplina de Introdução à Programação Tabela. incrementar i e decrementar j • O grupo esquerdo (com valores ≤ x) é v[0].imprime(tabela). .Algoritmo QuickSort É um algoritmo recursivo baseado na técnica divide and conquer! o Escolher um elemento arbitrário (x) da tabela (chamado pivot) o Passo de Divisão ƒ Dividir os restantes em dois grupos (esquerdo e direito).. ƒ O elemento pivot é colocado entre os dois grupos. trocar v[i] com v[j]. Poderá ser introduzido o seguinte refinamento: • Inicializar i = 0 (índice da 1º posição da tabela). • Inicializar j = n-1 (índice da última posição da tabela). ƒ O grupo esquerdo é composto pelos elementos menores ou iguais que o elemento pivot. incrementar i ƒ Enquanto v[j] > x (é sempre j≥ 0). //ordena tabela Tabela..troca(numbers. o Passo Recursivo ƒ Ordenar os dois grupos esquerdo e direito. fazer: ƒ Enquanto v[i] < x (é sempre i≤ n-1). //imprime tabela depois de ordenada } } 8. usando o mesmo método recursivamente Relativamente ao passo da divisão: • Seja a Tabela v com n elementos.

tabela. //imprime tabela depois de ordenada } static void quickSort (int tabela[].3) j i 3 1 2 5 4 6 9 8 7 (3. //ordena tabela Tabela. Sebenta da Disciplina de Introdução à Programação n * log n onde n é o numero de elementos a serem ordenados.3) j i 3 1 2 4 5 6< 9 8 7 ≤x ≥x Figura 51.length-1).1+3.3) i j 3 9 2 5 4 6 1 8 7 (3.1+3. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 128 .imprime(tabela). Passo da divisão O código da implementação do algoritmo é apresentado em seguida: public static void main(String[] args) { int tabela[] = new int[100].2) i j 8 9 2 5 4 6 1 3 7 (3. int pri.imprime(tabela). i x=4 j v: 8 9 2 5 4 6 1 3 7 (3. Veremos em seguida um exemplo do passo da divisão. //imprime tabela antes da ordenação quickSort(tabela.2) i j 3 1 2 5 4 6 9 8 7 (3. //preenche tabela Tabela. int j = ult. int ult) { int i = pri.preenche(tabela). Tabela. 0. A ideia “de aceleração” por trás do algoritmo QuickSort é que é mais rápido ordenar duas sequências de n/2 elementos do que uma sequência de n elementos.

1 .Implemente um método que receba como parâmetro uma tabela de inteiros e retorne a tabela ordenada usando o algoritmo Bubble Sort Exerc. Exerc.j--). Sebenta da Disciplina de Introdução à Programação int pivot = tabela[(pri + ult)/2]. }while(i <= j).Implemente um programa que: 1. laranja. if (pri < j) quickSort(tabela. if (i < ult) quickSort(tabela. } } 8. while (tabela[j] > pivot) j--. castanho. Implemente o método que permite reordenar a tabela de objectos ArtigoVestuario segundo a ordem de cores desejada public class ArtigoVestuario { public int cod.4 . i. … } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 129 .Implemente um método que receba como parâmetro uma tabela de inteiros e retorne uma outra tabela ordenada. sendo a ordem de cores desejada (amarelo.3 . verde. Para isso precisa de fazer uma pequena alteração à aplicação de suporte à gestão da loja. guarde estes registos numa tabela 3. cor. azul. Exerc. receba o registo de automóveis (Marca e n.troca(tabela. public String artigo.i++. 4.5 .Implemente um programa que dado uma tabela de caracteres a ordene o algoritmo Selection Sort.6 . segundo o método quick Sort.º registo) 2. do { while (tabela[i] < pivot) i++. Exerc.Faça um método que receba como parâmetro uma tabela de objectos do tipo funcionário (nome e número fiscal) e retorne uma tabela ordenada. if (i<= j) Tabela.6 . cinzento e preto). Use o algoritmo Selection Sort.2 . Apresente em seguida o resultado no ecran. ult). vermelho.Uma loja pretende dispor os seus artigos de vestuário segundo cores. pri. j). Use o algoritmo Shell Sort Exerc. Ordene a tabela por marca. beje.Exercícios práticos Exerc. de modo a acrescentar a funcionalidade de listagem de artigos por ordem de cor.

No exemplo do cálculo do factorial este critério é dado por 1!=1. • Procurar o significado de uma palavra num dicionário. • Recursiva (ou implícita).1 .Definições A repetição de execução de um grupo de instruções para diferentes valores de dados pode ser implementada de duas formas: • Iterativa (ou explícita). O uso da recursão é útil na resolução de problemas que podem ser decompostos em subprogramas mais simples e onde a solução final obtém-se pela composição das soluções desses subproblemas. • O caso geral. Como um método F resolve um problema chamando a si mesmo? O F chama a si em diferentes instâncias. contudo a recursividade pode causar problemas de memória em virtude da duplicação de variáveis locais. ou parte recursiva. por exemplo. Recursividade. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 130 . Por exemplo. Exemplos: • Examinar todos os arquivos de um directório D. No exemplo do cálculo do factorial este caso é n!=n*(n-1)! A recursividade é muito usada. Um método recursivo é definido em termos de uma instância menor de si mesmo. • Definição de uma expressão aritmética numa linguagem de programação. Devem existir duas condições fundamentais para implementar a recursividade: • Um caso elementar (ou critério de paragem). No mínimo. Sebenta da Disciplina de Introdução à Programação 9. sempre leva a um código mais compacto. incluindo os parâmetros. Exemplos: No exemplo seguinte será apresentado o cálculo do factorial de um número natural através da forma iteractiva e recursiva. incluindo todos os sub-directórios. Também devemos ter cuidado para não criar uma lógica circular que resulte em laços infinitos. sempre tem que haver um caso que pode ser resolvido sem recursividade. no cálculo de problemas matemáticos. Este pode ser feito de duas formas: • Forma iterativa n! = n*(n-1)*(n-2)*…*1 • Forma recursiva (definindo-se uma forma recursiva da função) 1!=1 n! = n*(n-1)! Um método recursivo é um método que directa ou indirectamente faz uma chamada a si mesmo (recorre a si próprio para resolver o problema). vejamos o cálculo do factorial de um número natural. Qualquer chamada recursiva tem que progredir em direcção ao caso elementar. Recursividade é uma poderosa ferramenta de programação que pode levar a algoritmos pequenos e eficientes. com os valores diferentes. Quando um método está definido em termos dele próprio. Recursividade 9.

println("f(" + i + ") = " + fact(i)). return n*fact(n-1). while (n > 1) f *= n--. } static long fact(int n) { if (n < 2) return 1. i < 9. i < 9.out. Sebenta da Disciplina de Introdução à Programação Iterativa public class FacInt { public static void main(String[] args) { for (int i = 0. } } /* Output: f(0) = 1 f(1) = 1 f(2) = 2 f(3) = 6 f(4) = 24 f(5) = 120 f(6) = 720 f(7) = 5040 f(8) = 40320 */ Recursiva public class TestFactorialRec { public static void main(String[] args) { for (int i = 0. return f. i++) System.println("f(" + i + ") = " + factorial(i)). } } /* © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 131 .out. } static long factorial(int n) { long f = 1. i++) System.

Exercícios práticos Exerc. 34.4 . Em que cada elemento desta sequência é a soma dos dois elementos precedentes: Nota: Se n <= 2 então Fib(n) := 1. . mas mascarado por uma estrutura de selecção. que permita obter o resultado de A+B sendo A e B inteiros não negativos. Faça um programa que calcule o número da sequência de Fibonacci: ƒ Iterativamente ƒ Recursivamente Exerc.. que permita obter o resultado de A*B sendo A e B inteiros não negativos.2 – Escreva um algoritmo recursivo e respectivo método. 21. Se n > 2 então Fib(n) : = Fib(n-2)+ Fib(n-1).Escreva um método recursivo que calcula e retorna o valor de S(n). 1.. 3. Em que Fib(n) retorna o n-ésimo termo da sequência. 8. onde © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 132 . Exerc. Sebenta da Disciplina de Introdução à Programação Output: f(0) = 1 f(1) = 1 f(2) = 2 f(3) = 6 f(4) = 24 f(5) = 120 f(6) = 720 f(7) = 5040 f(8) = 40320 */ Veja-se para este último caso o rasto do cálculo do factorial f(3) = 3 * f(2) = 6 | 2 * f(1) = 2 | 1*1=1 Para finalizar. 5. Nota: a*b = a if b=1 a*b =a*(b-1)+a Exerc.Faça um método recursivo que calcule o valor de S. 2.3 – A sequência de Fibonacci é definida como: 1. repare-se que: • Numa implementação iterativa o ciclo está presente explicitamente como estrutura de repetição.5 . • Numa implementação recursiva o ciclo está presente. 9. 13. onde S = 1 + ½ + 1/3 + ¼ + 1/5 + 1/N.2 .1 – Escreva um algoritmo recursivo e respectivo método. Nota: a+b = a if b=0 a+b =(a+1) + (b-1) Exerc.

13 .Faça uma função recursiva que calcule o mdc entre dois números: mdc(n1.. c(n − 1) + c(1).6 . Exerc.n) = A(m-1.c(1) + c(n − 1) .Faça um método recursivo que ordene por ordem crescente os n elementos de um vector de inteiros de n posições.10 – Escreva um programa contendo o seguinte método recursivo que retorna o n-ésimo número Catalão: static long c( int n) A sequência dos números Catalão é dada por : 1 1 2 5 14 42 132 429 . se n2 != 0 Exerc.Escreva um método recursivo que calcula e retorna o valor de S(n)..n2) = mdc( n2.11 . +(n*2+1)/(n+3) Exerc. n1 mod n2).. se n2 = 0 mdc(n1.m) + X(n-1.n2) = n1 . Exerc. dada pela seguinte relação: Nota: 1 se m = 0 A(m.A(m. c(0) i =0 Para efeitos comprovativos.12 . Sebenta da Disciplina de Introdução à Programação S = 1 + 1/1! + ½! + 1/3! + 1 /N!.n-1)) se m>0 e n>0 Exerc. (n + 1)! Exerc. inicio se (n=m) ou (m=0) entao X = 1 senao X = X(n-1. utilize a seguinte expressão e compare os resultados da sequência obtida: (2n)! c ( n) = n!.m: inteiro): inteiro. Exerc... onde S = 2/4 + 5/5 + 10/6 + 17/7 + 26/8 + .Faça um método recursivo que recebe um inteiro e retorna o seu número de dígitos..3) ? Quantas chamadas serão feitas na avaliação acima ? © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 133 . Em termos matemáticos a sua relação é dada por : n −1 c (n) = ∑ c(i ) .1) se m>0 e n=0 A(m-1. Exerc. + c(n − 2).Escreva um método recursivo que calcula e retorna a função potência Xⁿ.m-1) fim Qual o valor de X(5..c(n − 2) + .7 . em seguida. c(n − 1 − i ) = c(0) .Dada a função X definida abaixo: Algoritmo X(n.9 – Escreva um método para calcular o valor da função de Ackmann.8 .

} // metodos selectores public int getNumero() { return numero. } public String getNome() { return nome. curso=curs. int num. numero =num. valorPago=0. } public String getCurso() { return curso. private char turma. char turm) { nome = nom.Anexo I – Exemplo Introdutório em Java Neste anexo apresenta-se a título de exemplo introdutório ao Java a classe Aluno que foi teoricamente explicada no capitulo 2. } public char getTurma() { return turma. String curs. int an. //CONSTRUTORES public Aluno(String nom. turma=turm. private double valorPropina. private String curso. valorPropina=0. } public int getAno() { return ano. private int numero. private int ano. ano=an. private double valorPago. Sebenta da Disciplina de Introdução à Programação 10 . } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 134 . public class Aluno { //ATRIBUTOS private String nome.

} // metodo que verifica se a propina já foi paga public boolean verificaPropinaPaga() { boolean resultado=calculaDivida()==0. } // outros métodos public String toString() { String str= "Nome:" + nome + "Numero :" + numero + " curso : " + curso + " ano" + ano. Sebenta da Disciplina de Introdução à Programação public double getPropina() { return valorPropina. } // metodos modificadores public void setCurso(String curs) { curso=curs. } } © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 135 . } // metodo que calcula a divida public double calculaDivida() { return valorPropina-valorPago. return resultado. } public double getValorPago() { return valorPago. }. return str. } public int setAno() { return ano. // metodo que calcula valor da propina ja pago public void pagarPropina(double valor) { valorPago=valorPago+valor. } public void setPropina(double valor) { valorPropina=valor. } public void setTurma(char turm) { turma=turm.

Código executável: Resultado da compilação do código fonte. tem um estado inicial que corresponde ao valor do resultado que ainda não existe. Bottom-Up: Construção de uma solução partindo dos elementos mais pequenos. Compilador: Programa que sabe interpretar o código escrito numa determinada linguagem de programação. Algoritmo: Conjunto de instruções que resolvem um problema. etc. Divide-And-Conquer: Metodologia ou forma de resolução de problemas que envolve partir um problema em subproblemas mais pequenos. Compilação: Processo de gerar código executável a partir de código fonte recorrendo a um compilador. etc. os símbolos musicais servem para definir músicas nas partituras. Estado: Situação em que se encontra uma variável em termos de valor actual. Conceber: Criar. Linguagem de Programação: Linguagem artificial utilizada para levar a cabo a implementação de programas de computador. colunas. Por exemplo: a BNF serve para definir gramáticas para variados tipos de linguagens. Ambiguidade: Expressão cujo significado não pode ser determinado a partir do contexto em que está inserida (ou seja. As palavras encontram-se descritas por ordem alfabética. Abordagem: conjunto de acções tomadas para definir a forma de atingir a solução de um determinado problema. etc. tal como o XML serve para definir formato de dados. Notação: Mecanismo que serve para definir o formato de determinado tipo de informação. podendo levar a resultados diferentes). Código fonte: Código escrito pelo programador.) Implementação: Código produzido por um programador e que representa uma solução possível para um determinado problema. e um estado final que é o valor de resultado após passar pela fase de transformação. Máquina Virtual: Na prática é um computador simulado dentro do próprio computador através de software próprio criado para esse efeito.Anexo II – Glossário Nota: Os significados apresentados para as palavras colocadas neste glossário são apenas os que se consideraram necessários no âmbito da cadeira de Introdução à Programação. Hardware: Componentes físicos de um computador (discos. Sebenta da Disciplina de Introdução à Programação 11 . O estado de um objecto é o conjunto de valores dos seus atributos. monitores. que a partir de determinado ponto oferece mais do que um caminho a seguir. No que diz respeito a um problema. Comporta-se como se fosse um computador independente. Recebe código fonte como elemento de entrada e produz código executável. cujas soluções combinadas representam a solução do problema original. A máquina virtual Java actua como um ambiente de execução de programas Java auto-contido. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 136 .

ou seja. como também tem de gerir a memória disponível para cada aplicação(programa em execução. Sebenta da Disciplina de Introdução à Programação Operandos: elementos envolvidos numa determinada operação. © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 137 . é uma notação de representação de números. Top-Down: Cosntrução de uma solução em que a partir do problema maior se tenta ir descendo de nível e especificando a cada passo os níveis intermédios. Quotidiano: algo relativo ao dia-a-dia. Sistema Operativo: Programa de computador de grandes dimensões e complexidade que é responsável não só por esconder os detalhes do hardware aos utilizadores e programadores. etc. os problemas mais pequenos. Pseudocódigo: forma simplificada de descrever um algoritmo recorrendo a palavras chave semelhantes às da linguagem natural. ao contrário do hardware que representa a parte física de um computador. Subprograma: Também chamados de rotinas (ou métodos no caso de linguagens orientadas a objectos como é o caso do Java). Sistema de Numeração: Esquema de representação de magnitudes ou quantidades através de um grupo de dígitos. Software: Programa de computador. são pequenos programas que podem ser chamados e chamar outros programas para que em conjunto colaborem na obtenção de uma solução para determinado problema. mas que são estruturadas à semelhança de um programa de computador. também chamado de processo) e gerir a execução dessas mesmas aplicações. Representa a parte lógica. gerir o sistema de comunicação com outras máquinas. Basicamente.

Addison Wesley ƒ Acetatos de IP dos anos lectivos 2000/2001 até 2003/2004 © Escola Superior de Tecnologia de Setúbal 2005-2006 Página 138 . Maria José Marcelino. FCA ƒ Introdução à Programação Utilizando Pascal.Bibliografia ƒ Fundamentos de Programação em Java2 – António Mendes. John Lewis. McGraw-Hill ƒ The Java Programming Language – Ken Arnold. FCA ƒ Java Software Solutions. Pavão Martins. James Gosling .Anexo III . Addison Wesley ƒ Programação em Java2 – Pedro Coelho. Sebenta da Disciplina de Introdução à Programação 12 .