1 - Computadores e Programação
1.1 Introdução........................................................................................................................................... 1
1.2 Computador, a grande revolução do século XX.................................................................................... 2
1.3 O que é um computador?..................................................................................................................... 3
1.4 Qual é a utilidade de um computador?.................................................................................................. 4
1.5 Classe de problemas que o computador resolve.................................................................................... 5
1.6 Organização interna de um computador................................................................................................ 6
1.7 O que é o sistema operativo?............................................................................................................... 10
1.8 Linguagens de programação................................................................................................................. 11
1.8.1 Linguagem máquina....................................................................................................................... 12
1.8.2 Linguagens de baixo nível.............................................................................................................. 12
1.8.3 Linguagens de alto nível................................................................................................................ 13
1.8.4 Que linguagem se deve usar para ensinar programação?................................................................ 17
1.9 Paradigmas de programação................................................................................................................ 19
1.10 Fases do desenvolvimento de uma aplicação...................................................................................... 24
1.10.1 Análise do problema................................................................................................................... 25
1.10.1.1 Especificação do problema.................................................................................................. 25
1.10.1.2 Análise algorítmica............................................................................................................... 27
1.10.1.3 Teste do algoritmo............................................................................................................... 28
1.10.2 Implementação da aplicação....................................................................................................... 29
1.10.2.1 Geração do código.............................................................................................................. 29
1.10.2.2 Teste e validação do código................................................................................................. 32
1.11 Princípios a ter em conta no desenvolvimento de software de qualidade............................................. 33
1.12 O ambiente de programação em Java................................................................................................ 34
1.13 O sistema operativo UNIX................................................................................................................ 35
1.13.1 Identificação dos utilizadores...................................................................................................... 36
1.13.2 Organização da memória de massa............................................................................................. 37
1.13.3 O interpretador de comandos (shell).......................................................................................... 38
1.13.4 Os comandos mais usuais do UNIX........................................................................................... 39
1.13.4.1 Comandos para processar directórios.................................................................................. 40
1.13.4.2 Comandos para processar ficheiros...................................................................................... 41
1.13.4.3 Editores de texto................................................................................................................. 43
1.13.5 Redireccionamento de entrada/saída de comandos...................................................................... 43
1.13.6 Execução de programas.............................................................................................................. 45
Leituras Recomendadas............................................................................................................................. 46
2 - Algoritmos
2.1 Introdução........................................................................................................................................... 47
2.2 Especificação do problema................................................................................................................... 48
2.3 Algoritmos e suas características........................................................................................................... 49
2.4 Decomposição hierárquica da solução.................................................................................................. 50
2.5 Regras gramaticais do pseudocódigo.................................................................................................... 52
2.6 Modelos de algoritmos......................................................................................................................... 62
2.6.1 Modelo básico.............................................................................................................................. 62
2.6.2 Modelo básico modificado à entrada............................................................................................. 62
2.6.3 Modelo básico modificado à saída................................................................................................. 73
Exercícios.................................................................................................................................................. 84
3 - Representação da Informação
3.1 Introdução........................................................................................................................................... 89
3.2 Sistemas de numeração........................................................................................................................ 90
3.2.1 O sistema de numeração decimal................................................................................................... 90
3.2.2 O sistema de numeração binário.................................................................................................... 91
3.2.3 Os sistemas de numeração octal e hexadecimal.............................................................................. 92
3.2.4 Conversão decimal para binário..................................................................................................... 93
3.3 Representação de quantidades inteiras.................................................................................................. 94
3.3.1 Representação em sinal e módulo.................................................................................................. 94
3.3.2 Representação em complemento para um...................................................................................... 95
3.3.3 Representação em complemento para dois.................................................................................... 97
3.4 Aritmética inteira.................................................................................................................................. 99
3.5 Representação de quantidades reais..................................................................................................... 102
3.6 Aritmética real..................................................................................................................................... 107
3.7 Representação de símbolos................................................................................................................. 111
3.8 Big Endien versus Little Endien........................................................................................................ 112
Exercícios................................................................................................................................................. 113
Leituras Recomendadas............................................................................................................................ 114
4 - Introdução à Linguagem Java
4.1 Introdução.......................................................................................................................................... 115
4.2 A estrutura de um programa em Java................................................................................................... 116
4.3 Elementos básicos da linguagem Java................................................................................................... 118
4.4 Representação da informação.............................................................................................................. 121
4.5 Tipos de dados primitivos.................................................................................................................... 123
4.5.1 Tipos de dados aritméticos........................................................................................................... 123
4.5.1.1 Tipos de dados inteiros......................................................................................................... 124
4.5.1.2 Tipos de dados reais............................................................................................................. 124
4.5.1.3 Tipo de dados carácter......................................................................................................... 125
4.5.2 Tipo de dados booleano.............................................................................................................. 125
4.6 Constantes e variáveis......................................................................................................................... 126
4.7 Sequenciação...................................................................................................................................... 128
4.7.1 Expressões................................................................................................................................... 129
4.7.2 Conversões.................................................................................................................................. 130
4.7.3 Operadores.................................................................................................................................. 132
4.7.3.1 Operadores aritméticos.......................................................................................................... 132
4.7.3.2 Operadores relacionais.......................................................................................................... 134
4.7.3.3 Operadores lógicos............................................................................................................... 134
4.7.3.4 Operadores para manipulação de bits.................................................................................... 135
4.7.4 Instruções de atribuição................................................................................................................ 136
4.7.5 Associatividade e precedência dos operadores.............................................................................. 140
4.8 Exemplo de um programa.................................................................................................................... 141
4.9 Classes da interface de programação................................................................................................... 143
4.9.1 A classe Character....................................................................................................................... 143
4.9.2 A classe Math.............................................................................................................................. 144
Exercícios.................................................................................................................................................. 146
5 - Entrada e Saída Formatadas de Dados
5.1 Introdução........................................................................................................................................... 149
5.2 Interacção entre a aplicação e o utilizador............................................................................................. 151
5.3 A classe System................................................................................................................................... 151
5.4 A classe JOptionPane........................................................................................................................... 155
5.5 A classe Scanner.................................................................................................................................. 156
5.6 As classes ProgConsole e WIO........................................................................................................... 163
5.6.1 Janela de interacção...................................................................................................................... 164
5.6.2 Entrada de dados.......................................................................................................................... 164
5.6.3 Saída de dados............................................................................................................................. 167
5.7 A função printf..................................................................................................................................... 169
5.7.1 Escrita de booleanos..................................................................................................................... 171
5.7.2 Escrita de caracteres..................................................................................................................... 171
5.7.3 Escrita de numéricos..................................................................................................................... 172
Exercícios.................................................................................................................................................. 174
6 - Estruturas de Controlo
6.1 Introdução........................................................................................................................................... 175
6.2 Instruções decisórias............................................................................................................................ 175
6.2.1 A instrução decisória binária if....................................................................................................... 176
6.2.2 A instrução decisória múltipla switch............................................................................................. 178
6.2.3 Comparação das instruções decisórias........................................................................................... 180
6.3 Instruções repetitivas............................................................................................................................ 181
6.3.1 As instruções repetitivas do while e while...................................................................................... 181
6.3.2 A instrução repetitiva for............................................................................................................... 184
6.3.3 Ciclos repetitivos imbricados.......................................................................................................... 186
6.3.4 Ciclos repetitivos infinitos............................................................................................................... 188
6.3.5 A instrução nula............................................................................................................................. 188
6.3.6 As instruções de salto break e continue........................................................................................ 189
6.4 Exemplos.............................................................................................................................................. 190
Exercícios................................................................................................................................................... 193
7 - Programação Procedimental
7.1 Introdução.............................................................................................................................................199
7.2 Subprogramas....................................................................................................................................... 201
7.3 Funções da linguagem Java.................................................................................................................... 203
7.3.1 Definição de uma função................................................................................................................. 203
7.3.2 Invocação de uma função............................................................................................................... 205
7.3.3 Uso indevido de funções................................................................................................................. 206
7.3.4 Procedimentos na linguagem Java.................................................................................................... 206
7.3.5 Parâmetros formais......................................................................................................................... 207
7.3.6 Passagem dos tipos de dados primitivos.......................................................................................... 208
7.3.7 Exemplos simples........................................................................................................................... 210
7.3.8 Visibilidade das variáveis................................................................................................................ 216
7.4 Criação de novos tipos de dados........................................................................................................... 218
7.4.1 Tipos de dados referências............................................................................................................. 218
7.4.2 Classes da linguagem Java.............................................................................................................. 220
7.4.3 Comparação dos tipos de dados primitivos e referências................................................................. 221
7.4.4 Passagem dos tipos de dados referências........................................................................................ 223
7.4.5 Exemplos avançados...................................................................................................................... 225
7.5 Organização de um programa em subprogramas.................................................................................... 239
7.6 Subprogramas recursivos...................................................................................................................... 239
Exercícios................................................................................................................................................... 240
8 - Sequências
8.1 Introdução............................................................................................................................................ 245
8.2 Características das sequências............................................................................................................... 246
8.2.1 Declaração de uma sequência......................................................................................................... 246
8.2.2 Inicialização de uma sequência........................................................................................................ 248
8.2.3 Sequências como parâmetros de subprogramas.............................................................................. 249
8.2.4 Sequências como resultado de saída de funções.............................................................................. 251
8.2.5 Cópia de sequências....................................................................................................................... 252
8.2.6 Exemplos....................................................................................................................................... 253
8.3 A classe ArrayList................................................................................................................................. 259
8.4 Exemplos mais complexos..................................................................................................................... 261
8.5 Sequências bidimensionais..................................................................................................................... 275
8.5.1 Exemplo de processamento de matrizes.......................................................................................... 278
8.6 Sequências tridimensionais.................................................................................................................... 285
8.7 Sequências de tipos de dados referências.............................................................................................. 287
8.7.1 Declaração e criação de uma sequência de registos........................................................................ 287
8.7.2 Exemplos de bases de dados......................................................................................................... 288
8.8 Considerações finais sobre sequências.................................................................................................. 299
Exercícios.................................................................................................................................................. 300
9 - Sequências de Caracteres
9.1 Introdução............................................................................................................................................ 307
9.2 Características das sequências de caracteres.......................................................................................... 308
9.2.1 Declaração de sequências de caracteres......................................................................................... 308
9.2.2 Conversão entre sequências de caracteres e agregados de caracteres.............................................. 309
9.2.3 Atribuição de sequências de caracteres........................................................................................... 311
9.2.4 Sequências de caracteres versus caracteres.................................................................................... 311
9.2.5 Acesso aos caracteres das sequências de caracteres........................................................................ 312
9.2.6 Leitura e escrita de sequências de caracteres................................................................................... 312
9.2.7 Passagem do tipo de dados String aos subprogramas...................................................................... 313
9.2.8 Sequências de caracteres como parâmetros de subprogramas......................................................... 318
9.2.9 Sequências de caracteres como resultado de saída de funções........................................................ 318
9.3 Exemplos simples.................................................................................................................................. 320
9.4 A classe String...................................................................................................................................... 328
9.5 Exemplo avançado................................................................................................................................ 334
9.6 A classe StringBuffer............................................................................................................................. 335
9.7 Sequências de sequências de caracteres................................................................................................ 338
Exercícios................................................................................................................................................... 340
10 - Ficheiros
10.1 Introdução.......................................................................................................................................... 349
10.2 Fluxos de comunicação....................................................................................................................... 350
10.3 Fluxos de texto................................................................................................................................... 351
10.3.1 Abertura de um ficheiro de texto para leitura................................................................................ 352
10.3.2 Fecho de um ficheiro de texto...................................................................................................... 353
10.3.3 Leitura de um ficheiro de texto..................................................................................................... 353
10.3.4 Exemplos de leitura de ficheiros de texto...................................................................................... 354
10.3.5 Abertura de um ficheiro de texto para escrita............................................................................... 358
10.3.6 Escrita num ficheiro de texto........................................................................................................ 359
10.3.7 Exemplos de escrita de ficheiros de texto..................................................................................... 359
10.4 Passagem de argumentos na linha de comando.................................................................................... 361
10.5 Exemplos........................................................................................................................................... 362
10.5.1 Exemplos simples de utilização de ficheiros de texto..................................................................... 362
10.5.2 Gestão de uma base de dados com ficheiros de texto................................................................... 368
10.6 Fluxos binários................................................................................................................................... 372
10.6.1 Gestão de uma base de dados com ficheiros binários................................................................... 373
10.7 Funções para operar sobre ficheiros................................................................................................... 375
Exercícios.................................................................................................................................................. 377
11 - Introdução à Pesquisa, Selecção e Ordenação
11.1 Introdução.......................................................................................................................................... 381
11.2 Complexidade algorítmica................................................................................................................... 382
11.3 Pesquisa............................................................................................................................................. 385
11.3.1 Pesquisa sequencial...................................................................................................................... 386
11.3.2 Pesquisa binária........................................................................................................................... 387
11.3.3 Comparação entre as pesquisas sequencial e binária..................................................................... 390
11.4 Selecção............................................................................................................................................. 390
11.4.1 Selecção do maior valor............................................................................................................... 391
11.4.2 Selecção do menor valor.............................................................................................................. 391
11.4.3 Selecção do primeiro valor que serve........................................................................................... 392
11.4.4 Selecção do melhor valor que serve............................................................................................. 392
11.4.5 Selecção do pior valor que serve................................................................................................. 393
11.4.6 Exemplificação dos algoritmos de selecção................................................................................... 393
11.5 Ordenação......................................................................................................................................... 394
11.5.1 Ordenação por selecção.............................................................................................................. 395
11.5.2 Ordenação por troca................................................................................................................... 397
11.5.3 Ordenação por inserção.............................................................................................................. 400
11.5.4 Comparação dos algoritmos de ordenação................................................................................... 402
11.6 Ordenação por fusão.......................................................................................................................... 403
Exercícios................................................................................................................................................... 405
Índice Remissivo