Fundamentos de Programação em JAVA (4.ª Ed. Atualizada e Aumentada)

VII© FCA - Editora de Informática

Índice geralÍndice geral

Agradecimentos .........................................................................................................................XI

Sobre o livro ..............................................................................................................................XIII

1 - Criação de um programa ......................................................................................................1

1.1 Resolução de problemas ............................................................................................................ 11.1.1 Resolução de problemas em computador........................................................................ 61.1.2 Técnicas de descrição de algoritmos ............................................................................. 101.1.3 Criação de algoritmos ................................................................................................... 12

1.2 Do algoritmo ao programa ....................................................................................................... 121.2.1 Representação digital de informação ............................................................................ 121.2.2 Componentes de um computador .................................................................................. 141.2.3 Linguagens de programação ......................................................................................... 151.2.4 A linguagem JAVA ....................................................................................................... 16

1.3 Executar um programa ............................................................................................................. 171.3.1 Tradução de linguagens de programação ...................................................................... 181.3.2 Compilar um programa em JAVA ................................................................................ 18

1.4 Um primeiro programa em JAVA ........................................................................................... 20O problema do Gestor Orçamental .................................................................................................. 25Resumo ............................................................................................................................................ 26Exercícios propostos ........................................................................................................................ 27

2 - Manipulação de informação simples ...........................................................................29

2.1 Estrutura de um programa ........................................................................................................ 292.2 Variáveis .................................................................................................................................. 312.3 Constantes ................................................................................................................................ 322.4 Tipos de dados primitivos ........................................................................................................ 32

2.4.1 Representação de números inteiros ............................................................................... 332.4.2 Representação de números reais ................................................................................... 332.4.3 Representação de carateres ........................................................................................... 342.4.4 Representação de valores lógicos ................................................................................. 35

2.5 Instrução de atribuição ............................................................................................................. 352.6 Expressões ................................................................................................................................ 36

2.6.1 Expressões aritméticas .................................................................................................. 362.6.2 A classe Math ................................................................................................................ 392.6.3 Conversões de tipo ........................................................................................................ 392.6.4 Expressões lógicas ........................................................................................................ 41

O problema do Gestor Orçamental .................................................................................................. 42Resumo ............................................................................................................................................ 42Exercícios propostos ........................................................................................................................ 43

3 - Comunicação básica com o utilizador .........................................................................47

3.1 Escrita de mensagens ............................................................................................................... 47

Fundamentos de Programação em JAVAFundamentos de Programação em JAVA

X © FCA - Editora de Informática

10.7 Um exemplo – loja de material fotográfico ......................................................................... 226O problema do Gestor Orçamental ................................................................................................ 231Resumo .......................................................................................................................................... 232Exercícios propostos ...................................................................................................................... 235

11 - Coleções .............................................................................................................................239

11.1 Tipos genéricos .................................................................................................................... 23911.2 A classe ArrayList<E> ....................................................................................................... 240

11.2.1 Criação de um ArrayList ...................................................................................... 24111.2.2 Manipulação de um ArrayList .............................................................................. 242

11.3 A classe HashMap<K,V> ....................................................................................................... 24611.3.1 Criação de um HashMap<K,V> ................................................................................ 24711.3.2 Manipulação de um HashMap<K,V> ........................................................................ 247

O problema do Gestor Orçamental ................................................................................................ 253Resumo .......................................................................................................................................... 253Exercícios propostos ...................................................................................................................... 254

12 - Ficheiros ............................................................................................................................257

12.1 Fluxos de dados .................................................................................................................... 25712.2 Ficheiros de texto ................................................................................................................. 258

12.2.1 Manipulação de ficheiros de texto ........................................................................... 25912.2.2 A classe FicheiroDeTexto .................................................................................... 261

12.3 A classe Scanner ................................................................................................................. 26512.4 Ficheiros de objetos ............................................................................................................. 266

12.4.1 Manipulação de ficheiros de objetos ....................................................................... 26612.4.2 A classe FicheiroDeObjectos .............................................................................. 267

12.5 Exceções .............................................................................................................................. 271O problema do Gestor Orçamental ................................................................................................ 274Resumo .......................................................................................................................................... 274Exercícios propostos ...................................................................................................................... 276

13 - Interfaces gráficas ......................................................................................................279

13.1 Criação da interface ............................................................................................................. 27913.1.1 Desenho numa janela .............................................................................................. 28013.1.2 Adição de componentes à janela ............................................................................. 28313.1.3 Gestão de eventos .................................................................................................... 286

13.2 Um exemplo – animais da quinta ......................................................................................... 291O problema do Gestor Orçamental ................................................................................................ 297Resumo .......................................................................................................................................... 297Exercícios propostos ...................................................................................................................... 298

Anexo .........................................................................................................................................301

Glossário de termos correspondentes em português europeu e português do brasil ....................................................................................................305

Índice remissivo .......................................................................................................................307

XIII© FCA - Editora de Informática

Sobre o livroSobre o livro

Objetivos e abordagemEste livro tem como objetivo principal apoiar a aprendizagem de conceitos básicos de programação, utilizando, para isso, a linguagem JAVA. Os temas abordados correspondem às matérias que geralmente são lecionadas em disciplinas de introdução à programação de nível universitário. Os alunos destas disciplinas são os principais destinatários. No entanto, este livro pode ser útil para qualquer pessoa interessada em se iniciar na difícil, mas aliciante, arte de programar.

A aprendizagem da programação é uma tarefa complexa que coloca desafios importantes. Muitos alunos confundem aprender a programar com aprender a sintaxe de uma linguagem de programação. Nada poderia estar mais errado. Programar é, antes de mais, delinear estratégias que permitam resolver problemas. Aqui reside a grande dificuldade sentida por muitos alunos, mais habituados a tarefas de memorização e de aplicação automática de fórmulas.

Neste contexto, o papel de um livro de programação será, na nossa opinião, o de um auxiliar e de uma referência, que deve sugerir, apoiar e complementar tarefas práticas de programação. Nesta perspetiva, a ferramenta principal de um estudante de programação deverá ser um computador com as ferramentas necessárias para poder desenvolver programas. As características principais de um bom aluno de programação passam pelo método, pela agilidade mental, pela capacidade de trabalho, mas também pela persistência em não desistir perante um problema de difícil solução.

É claro que um computador só consegue executar programas escritos numa linguagem de programação, pelo que as soluções terão que ser expressas numa destas linguagens. A escolha da linguagem JAVA justifica-se por ser, na nossa opinião, aquela que entre as linguagens de programação utilizadas atualmente em ambientes profissionais mais se adequa a uma fase de aprendizagem. É uma linguagem que, nos seus aspetos básicos, apresenta uma sintaxe relativamente simples, cuja aprendizagem não é difícil para a maioria dos estudantes. A possibilidade de desenvolver applets que podem ser integrados em páginas Web pode desempenhar um papel relevante na motivação dos alunos. A nossa experiência enquanto docentes de disciplinas de introdução à programação vem reforçar esta convicção.

Sendo a linguagem JAVA uma linguagem orientada aos objetos, poderia parecer adequado iniciar a aprendizagem pelos conceitos fundamentais deste paradigma de programação.


XIV © FCA - Editora de Informática

No entanto, o paradigma de programação procedimental continua a ser muito utilizado, pelo que se torna importante a sua aprendizagem também. Para além disso, programar utilizando este paradigma é um excelente exercício para o desenvolvimento de capacidades de resolução de problemas que podem ser aplicadas nos mais diversos campos. Deste modo, mesmo correndo o risco de parecer pouco natural, consideramos que os alunos devem começar pelo paradigma procedimental, passando posteriormente ao paradigma orientado aos objetos. É desta forma que este livro está organizado.

Organização do livro

Conteúdos temáticos

Nos primeiros oito capítulos são apresentados os conceitos básicos da programação procedimental. Os restantes capítulos apresentam e usam conceitos da programação orientada aos objetos.

Sínteses e resumos

Cada capítulo inicia com uma síntese da matéria que irá ser tratada ao longo do mesmo e termina com um breve e útil resumo sobre os conteúdos explanados nesse capítulo.

Desafios, exercícios , problemas e sugestões

Destacados num lettering diferente com um filete lateral de cor cinza, são apresentados ao leitor desafios, exercícios, problemas e/ou sugestões, que lhes permitem colocar em prática, de forma autónoma, o que aprendeu em cada capítulo.

Exercícios propostos

No final de cada capítulo é proposto um conjunto de exercícios ao leitor. As soluções para alguns destes problemas podem ser encontradas na página Web de suporte a este livro em http://www.fca.pt. Recomenda-se vivamente que o leitor antes de ver as soluções propos-tas tente encontrar as suas próprias soluções para os problemas apresentados e só depois as compare com as soluções fornecidas.

Glossário de termos correspondentes em português europeu e português do Brasil

Uma novidade: este livro inclui, no final, um glossário com a correspondência dos principais termos técnicos em português europeu e português do Brasil e que poderá ser muito útil aos nossos leitores brasileiros.

Criação de um programaCriação de um programa

1© FCA - Editora de Informática

1 - Criaçãode um programa

1 - Criaçãode um programa

A informática e as comunicações desempenham um papel fundamental nas sociedades

modernas. Atualmente é difícil encontrar setores de atividade que não dependam, direta ou

indiretamente, do apoio de computadores.

O funcionamento dos computadores só é possível através da conjugação dos seus compo-

nentes físicos, o hardware, com programas, o software, que incluem as instruções a execu-

tar. Pode dizer -se que os programas fornecem conhecimentos e estratégias de resolução de

problemas, indispensáveis para que o computador possa desempenhar o seu papel. Cabe ao

programador fornecer estes conhecimentos e estratégias, pelo que a capacidade de encontrar

soluções para problemas é fundamental para um bom programador. A programação é, assim,

a arte de analisar um problema e encontrar um conjunto de ações (um algoritmo) capaz de o

resolver corretamente.

Este capítulo começa por apresentar o conceito de algoritmo e por descrever e exemplificar

algumas técnicas para o seu desenvolvimento (secção 1.1). Para desenvolver programas cor-

retos e eficazes, todo o programador necessita de ter um conhecimento sobre a estrutura e o

funcionamento de um computador, bem como sobre as diversas linguagens de programação

que pode utilizar. Alguns destes conceitos são abordados na secção 1.2, que inclui também

uma apresentação das características gerais da linguagem JAVA. Os passos necessários para

executar um programa, com particular ênfase no caso dos programas em JAVA, são aborda-

dos na secção 1.3. Finalmente, na secção 1.4, é feita uma primeira apresentação da estrutura

de um programa escrito nesta linguagem de programação.

1.1 Resolução de problemasA escrita de um programa de computador tem, normalmente, como objetivo resolver um ou

mais problemas. Contrariamente ao que se possa pensar, na maioria das vezes, a principal

dificuldade não reside na sintaxe ou na semântica da linguagem de programação utilizada,

mas na procura de soluções para o problema em causa, independentemente da forma ou da

linguagem usadas para descrever essas soluções. Assim sendo, o passo mais importante na

criação de um programa é a definição do seu algoritmo.


2 © FCA - Editora de Informática

Esta questão coloca -se também a quem se inicia na programação. Muitas vezes confunde -se

aprender a programar com aprender a sintaxe e a semântica de uma linguagem de progra-

mação. Na realidade, aprender a programar é bastante mais complexo. Um bom programa-

dor não é aquele que conhece até à exaustão todos os detalhes de uma linguagem de progra-

mação, mas aquele que é capaz de encontrar soluções eficazes para problemas de progra-

mação. Claro que um bom conhecimento da linguagem de programação utilizada é impor-

tante, mas de pouco serve sem uma boa capacidade de resolução de problemas.

Para que se possa encontrar uma solução para um determinado problema é, evidentemente,

necessário começar por o compreender. De seguida, o problema deve ser analisado no sen-

tido de procurar soluções adequadas. Muitos dos erros cometidos por programadores inex-

perientes são causados por uma deficiente compreensão e análise do problema que preten-

dem resolver. Se estas tarefas forem levadas a cabo com êxito, facilita -se em muito a cons-

trução de um programa, pois não é difícil codificar numa linguagem de programação uma

solução previamente construída e descrita (mesmo que de uma forma informal).

Evidentemente que, depois de escrever o código do programa, será necessário verificar se

o mesmo resolve o problema em causa. Para isso, é importante efetuar testes, utilizando

diversos conjuntos de dados de entrada, procurando abarcar todas as situações possíveis de

utilização.

A resolução de problemas é uma tarefa difícil, para a qual não há receitas nem fórmulas que

se possam aplicar em função do tipo de problema. Daí que dificilmente se obtém sucesso

utilizando estratégias de estudo que privilegiem a memorização da sintaxe de uma lingua-

gem ou de um conjunto de soluções para exercícios tipo. O método, a experiência e a agi-

lidade mental adquiridas com a prática ao longo do tempo são fundamentais. A aprendiza-

gem da programação é, assim, um processo baseado na prática e que exige tempo e expe-

riên cia. Programar é, pois, a melhor maneira de aprender a programar.

Uma das principais dificuldades da programação reside no facto de habitualmente ter de

se procurar soluções genéricas para os problemas e não soluções para um caso específico.

Veja -se um exemplo: dados os números 10, 30, 20 e 15 é fácil e imediato identificar qual

deles é o maior. No entanto, se se pretender um método genérico que identifique qual é o

maior de um conjunto de quatro números inteiros (n1, n2, n3 e n4), será necessário elabo-

rar um algoritmo detalhado que especifique todas as operações envolvidas. Neste caso, uma

vez que os números não são conhecidos, é necessário procurar uma solução genérica capaz

de determinar o maior de qualquer conjunto de quatro números. Algo como:

Comparar n1 com n2 e guardar o maior deles numa variável auxiliar i

Comparar n3 com n4 e guardar o maior deles numa variável auxiliar j

Comparar i com j, o maior deles será o maior dos quatro números

Vetores e matrizesVetores e matrizes


8 - Vetorese matrizes8 - Vetorese matrizes

Como já foi referido, as variáveis de qualquer tipo primitivo apenas podem conter um valor

em cada momento. Por exemplo, uma variável int só pode conter um número inteiro, uma

variável double só pode conter um número real e assim por diante.

Esta é uma limitação importante, pois em muitos programas é útil dispor de uma forma de

poder guardar um conjunto de valores sob um determinado nome. Por exemplo, considere-

-se que é necessário escrever um programa que leia uma lista de notas de alunos, calcule a

nota média e liste quais as notas acima da média. Uma vez que é necessário armazenar todas

as notas, poder-se-ia pensar na utilização de uma variável para cada uma delas. Esta solu-

ção, ainda que possível se for conhecido o número de alunos, apresenta desvantagens sérias.

Basta pensar o que sucederia se o número de alunos fosse elevado ou se, uma vez o programa

desenvolvido, o número de alunos se modificasse.

Neste capítulo, serão apresentadas estruturas de dados que permitem ultrapassar estas limi-

tações (secção 8.1) e as matrizes (secção 8.2).

8.1 VetoresUma solução melhor para o problema acima descrito passa pela utilização de uma tabela

unidimensional ou vetor. Um vetor é uma entidade que contém uma lista de elementos,

todos do mesmo tipo. Este conjunto de elementos é referenciado pelo nome do vetor, per-

mitindo, assim, agrupar um qualquer número de elementos do mesmo tipo sob uma única

designação. No caso do problema das notas, basta criar um vetor de números inteiros com

capacidade para armazenar todas as notas.

8.1.1 Criação de um vetor

A criação de um vetor apresenta algumas diferenças em relação à criação de variáveis dos

tipos primitivos. Em primeiro lugar, é necessário declarar uma referência para o vetor. Uma

referência é uma variável capaz de armazenar um endereço de memória, neste caso o ende-

reço de memória onde posteriormente vai ser criado o vetor. Uma referência para um vetor

de números inteiros pode ser criada através de:

int[] notas;



Esta declaração permite criar uma referência de nome notas que vai referenciar um vetor

de valores do tipo int. O par de parêntesis retos que aparece entre o tipo e o nome da refe-

rência indica que se trata de uma referência para um vetor. Uma vez obtida a referência, é

possível criar o vetor. Para isso, utiliza-se o operador new:

notas = new int[50];

Esta instrução cria um vetor com espaço para armazenar 50 números inteiros do tipo int.

Os 50 elementos ficam em posições consecutivas na memória e o endereço do primeiro ele-

mento fica armazenado na referência notas. Esta situação pode ser descrita pelo diagrama

da Figura 8.1:

notas

@

@ @+1 @+2 @+3 @+4 ... @+48 @+49

...

Figura 8.1 - Representação em memória de um vetor

A referência armazena o endereço do primeiro elemento do vetor, que foi representado no

diagrama pelo símbolo @. Dado que todos os elementos ficam em posições consecutivas de

memória, pode-se considerar que o segundo elemento fica em @+1, o terceiro em @+2 e

assim sucessivamente, até que o último elemento fica em @+49. Nesta representação, a uni-

dade é igual ao número de células de memória ocupadas por cada elemento. O programador

não tem, no entanto, que se preocupar com o endereço de memória onde fica cada elemento

do vetor, pois o acesso é feito através de índices e é o intérprete de JAVA que traduz esses

índices para as posições de memória ocupadas pelos elementos respetivos.

A declaração e a instrução de criação de um vetor podem ser fundidas numa única instrução:

int[] notas = new int[50];

A criação de vetores que contenham elementos de outros tipos é semelhante. Em seguida,

podem ser observados alguns exemplos:

//Cria um vetor capaz de armazenar 20 doubledouble[] vDouble = new double[20];

//Cria um vetor capaz de armazenar 20 booleanboolean[] vBoolean = new boolean[20];

Classes e objetosClasses e objetos


9 - Classes eobjetos

9 - Classes eobjetos

A programação orientada a objetos tem vindo a afirmar-se como uma alternativa válida para

o desenvolvimento de software. Na realidade, muitas das linguagens de programação moder-

nas, incluindo o JAVA, suportam este paradigma de programação.

Neste capítulo, é feita uma primeira abordagem à programação orientada a objetos,

nomeada mente, aos seus dois conceitos mais fundamentais: o conceito de classe e o con-

ceito de objeto.

Para além dos conceitos gerais sobre este tema, são apresentadas duas classes predefinidas de

utilização muito frequente: a classe String e a classe SringTokenizer.

É igualmente abordada a utilização de vetores de objetos, mostrando-se como permite a cria-

ção de estruturas de dados mais complexas.

9.1 Noções básicasA programação orientada aos objetos refere-se à construção de programas que funcionam

essencialmente à custa de entidades (objetos) que possuem características próprias e que

são capazes de desempenhar determinadas tarefas. É através destas funcionalidades e dos

mecanismos de interação entre objetos que os programas trabalham. Assim, de acordo

com este paradigma, desenhar um programa consiste em definir os objetos necessários, as

suas funcionalidades e o modo como comunicam entre si, de forma a atingir os objetivos

pretendidos.

Um objeto é uma combinação de dados ou atributos (variáveis) e ações (subprogramas)

íntima e logicamente relacionados. Na terminologia da programação orientada aos objetos

é comum denominar os subprogramas por métodos, pelo que daqui em diante é utilizada

esta designação.

Um objeto pode ser caracterizado por três componentes:

Identidade;



Atributos;

Comportamento.

A identidade permite ao programador e ao sistema identificar o objeto, os atributos per-

mitem caracterizá-lo, enquanto o seu comportamento define o conjunto de funcionalida-

des que pode executar por opção própria ou a pedido de outro objeto. É comum ter num

programa objetos semelhantes, com o mesmo comportamento, mas com atributos e identi-

dade diferentes.

Em JAVA, como em qualquer linguagem orientada aos objetos, não é possível definir obje-

tos sem definir primeiro a classe a que pertencem. Uma classe pode ser usada para criar um

ou mais objetos, definindo os seus atributos e comportamentos. Funciona como um molde

que pode ser utilizado para construir qualquer número de objetos semelhantes ou, dito de

outra forma, objetos dessa classe. Desta forma, a definição de uma classe implica a especi-

ficação dos atributos (variáveis) e dos comportamentos (métodos) que os objetos criados a

partir dela devem possuir.

Um objeto é, assim, definido como uma instância de uma classe e possui todas as variáveis

(atributos) e métodos (comportamentos) definidos para essa classe. Uma vantagem da pro-

gramação orientada aos objetos é, então, permitir reunir na mesma entidade os seus atribu-

tos e comportamentos, o que permite modelar de forma mais simples e aproximada os ele-

mentos do mundo real.

A relação entre uma classe e um objeto dessa classe é semelhante à relação entre uma

espécie e os diversos elementos dessa espécie. Por exemplo, a espécie cão define um con-

junto de características (nome, raça, cor) e comportamentos (correr, ladrar, etc...) que os

elementos dessa espécie possuem. Cada elemento da espécie tem estes atributos e é capaz

de apresentar estes comportamentos. Por exemplo, o Scott, elemento da espécie cão, da

raça Golden Retriever, castanho e que é capaz de correr e ladrar. Por outro lado, pode tam-

bém existir a Lassie, também elemento da espécie cão, da raça Pastor Alemão, cinzento e

também capaz de correr e ladrar. Transpondo este exemplo para a programação orientada

aos objetos, poderia existir uma classe Cao que definisse que os objetos desta classe tives-

sem os atributos nome, raca e cor e apresentassem os comportamentos correr e ladrar.

Posteriormente, seria possível criar objetos a partir do molde definido pela classe (os obje-

tos scott e lassie no exemplo). Cada um deles deveria ter valores para os atributos (um

nome, uma raça e uma cor) e seria capaz de apresentar os comportamentos definidos (cor-

rer e ladrar).

Princípios de programação orientada aos objetosPrincípios de programação orientada aos objetos


10 - Princípios deprogramação orientada

aos objetos

10 - Princípios de programação orientada

aos objetos

No Capítulo 9 foram apresentados os conceitos básicos que regem o funcionamento de clas-

ses e objetos, as estruturas fundamentais em programação orientada aos objetos.

No entanto, para tirar verdadeiro partido deste paradigma de programação, é necessário

conhecer e aplicar um conjunto de princípios que o tornam verdadeiramente poderoso. Em

particular, destacam-se o princípio do encapsulamento e as noções de herança e polimor-

fismo, os quais são centrais neste paradigma que, hoje em dia, é utilizado em muitos projetos

de desenvolvimento de software em larga escala.

Neste capítulo, para além de serem apresentados os conceitos de encapsulamento, herança e

polimorfismo, serão igualmente abordados outros aspetos relevantes, como sejam as classes

abstratas e as interfaces.

10.1 Mais sobre classes e objetosComo já foi referido, numa linguagem orientada aos objetos, os programas funcionam atra-

vés da criação de objetos, dos comportamentos que estes são capazes de apresentar e da

comunicação entre eles, sendo permitido a um objeto solicitar a outro um determinado

comportamento, de entre os que tem definidos. Os objetos não podem ser criados sem um

“molde” que defina os seus atributos e comportamentos. Este “molde” é a classe, pelo que

antes de criar um objeto é necessário que exista a respetiva classe. A partir desta podem

ser criados vários objetos, cada um deles com atributos próprios, mas com os mesmos

comportamentos.

As linguagens de programação orientadas aos objetos, como o JAVA, incluem muitas clas-

ses já definidas a partir das quais é possível criar de imediato objetos.

No entanto, na maior parte dos projetos de programação, a utilização exclusiva de classes

predefinidas na linguagem não é suficiente. Muitas vezes é necessário definir novas classes

que possam servir de “molde” a objetos que satisfaçam as necessidades do programador.



No caso da linguagem JAVA, a definição de classes obedece à seguinte sintaxe:

public class NomeDaClasse

{

//Declarações

//Construtores

//Métodos}

As variáveis de instância ou atributos, os construtores e os métodos de uma classe são gene-

ricamente chamados membros da classe.

A classe Rectangulo, definida no Capítulo 9, tem como membros quatro variáveis de ins-

tância, um construtor e quatro métodos:

public class Rectangulo

{

//Declaração de variáveis de instância private int posX, posY, comp, larg;

//Construtor (recebe os valores iniciais dos atributos) public Rectangulo(int pX, int pY, int c, int l)

public void desenhaRect(Graphics g)

public void apagaRect(Graphics g)

public void mudaPosicao(Graphics g, int pX, int pY)

public void mudaTamanho(Graphics g, int c, int l)

}

As declarações de variáveis efetuadas numa classe podem ser de dois tipos: variáveis de instância ou variáveis de classe.

As variáveis de instância servem para armazenar atributos específicos de cada objeto, como

sejam o comprimento ou a largura no caso dos retângulos. Cada objeto desta classe tem um

comprimento e uma largura, embora os seus valores possam ser diferentes de objeto para

objeto.

Documents

Fundamentos de Programação em JAVA (4.ª Ed. Atualizada e Aumentada)