OO Java - Sumário

Everton Coimbra de Araújo
Orientação a Objetos
com Java
Simples, Fácil e Eficiente
Visual
Books
Sumário
Prefácio ............................................................................ 11
Introdução ....................................................................... 13
1 Introdução à Orientação a Objetos ............................. 17
1.1 Conceitualização ........................................................................................ 17
2 Ferramenta para Implementação ................................ 23
2.1 Instalação do Java e do Eclipse ............................................................... 23
2.2 Testando o Java .......................................................................................... 24
2.3 Testando o Funcionamento do Eclipse ................................................. 30
2.4 Organização dos Arquivos no Eclipse ................................................... 31
2.4.1 Nomenclatura ......................................................................................... 31
3 Iniciando a Implementação em Orientação a Objetos ... 33
3.1 O Primeiro Problema a ser Resolvido .................................................... 33
3.2 Fazendo Uso de Modelos ......................................................................... 35
3.3 Outro Exemplo .......................................................................................... 37
3.3.1 Pedido de um Cliente em um Restaurante ......................................... 37
4 Conceitos para Implementação em Java ..................... 39
4.1 Conceitos e Pontos Importantes para Criação de Uma Classe
em Java ......................................................................................................... 39
4.1.1 Tipos de Dados ....................................................................................... 39
4.2 Testando a Classe Criada .......................................................................... 41
4.3 Testando Outra Classe .............................................................................. 43
5 Implementando uma Classe em Java através do
Eclipse .......................................................................... 45
5.1 Criando um Novo WorkSpace ................................................................. 45
5.2 Criando um Novo Projeto ........................................................................ 47
5.3 Criando uma Nova Classe ........................................................................ 49
5.4 Executando a Aplicação ........................................................................... 51
5.5 Implementação e Execução de Outra Classe ....................................... 53
6 Aplicando Técnicas de Orientação a Objetos na Classe
Implementada .............................................................. 55
6.1 Aplicando Encapsulamento na Classe ................................................... 56
6.1.1 Criando os Métodos para Acessar e Atribuir Valores aos
Atributos .................................................................................................. 58
6.2 Implementação e Execução de Outra Classe ....................................... 61
7 Garantindo a Consistência das Propriedades ............. 63
7.1 Evitando Atribuição de Valores Inválidos aos Atributos ................... 63
7.2 Implementação e Execução de Outra Classe ....................................... 66
8 Associação entre Objetos ............................................. 67
8.1 Identificando e Implementando Associações entre Classes ............... 67
8.2 Construtores ............................................................................................... 71
8.3 Garantindo a Associação entre as Classes através de Construtores . 72
8.3.1 Implementando os Construtores ......................................................... 72
8.3.2 Sobrecarga de Construtores (e métodos) ........................................... 74
8.3.3 Visualizando Graficamente os Objetos e suas Associações
através de Referências ........................................................................... 77
8.4 Implementação e Execução de Outra Classe ....................................... 80
9 Interagindo com o Usuário .......................................... 81
9.1 Pacotes - Packages .................................................................................... 81
9.2 Métodos Estáticos – Static ...................................................................... 85
9.3 Importando Classes e Pacotes ................................................................. 85
9.4 Criando Métodos para Entrada de Dados ............................................. 86
9.5 Testando a Classe de Interação com o Usuário .................................... 87
9.6 Implementação e Execução de Outra Classe ....................................... 90
10 Associando Coleções................................................... 91
10.1 Utilizando Arrays ..................................................................................... 91
10.1.1 Arrays em Java ...................................................................................... 92
10.2 Implementando uma Coleção de Objetos ........................................... 94
10.2.1 Inserindo os Elementos na Coleção.................................................. 95
10.2.2 Exibindo/Listando os Elementos de uma Coleção ....................... 98
10.3 Fazendo Uso da API Collections .......................................................... 99
10.3.1 Utilizando Generics ........................................................................... 101
10.4 Tirando a Responsabilidade de Exibir Dados da Classe ................ 103
10.4.1 Utilizando Foreach para Navegar em uma Coleção de Dados ... 104
10.5 Mudando o Estado de um Elemento de uma Coleção
Recuperada .............................................................................................. 105
10.5.1 Obtendo uma Nova Referência de uma Coleção ......................... 107
10.6 Fazendo Uso de um Iterator ................................................................ 109
10.7 Implementação e Execução de Outra Classe ................................... 110
11 Associações ................................................................. 111
11.1 Tipos e Características de Associações ............................................. 111
11.1.1 Agregação ............................................................................................ 112
11.1.2 Composição ......................................................................................... 119
11.2 Atividades para este Capítulo ............................................................. 123
12 Herança, Exceções e Polimorfismo ......................... 125
12.1 Definindo e Implementando Herança................................................ 125
12.1.1 Implementando Especializações ..................................................... 127
12.2 Implementando o Método Responsável pelo Desenho da Figura ...... 129
12.3 Desenhando as Figuras ......................................................................... 134
12.4 Entendendo os Modificadores de Escopo ........................................ 136
12.5 Tratamento de Erros com Exceções .................................................. 138
12.6 Entendendo os Métodos equals(), toString() e hashCode() ........... 139
12.6.1 Entendendo e Implementando o toString() ................................... 139
12.6.2 Utilizando Throws para Marcar um Método ................................. 144
12.6.3 Especializando uma Exceção .......................................................... 147
12.6.4 Validando Valores Recebidos e Disparando Exceções................ 148
12.6.5 Sobrecarga (Overhead) de Métodos ............................................... 150
12.6.6 Entendendo e Implementando o equals() e o hashCode() .......... 152
12.7 Interfaces – Herança por Implementação ......................................... 155
12.7.1 Criando uma Interface para Acesso a Dados ................................ 156
12.8 Polimorfismo .......................................................................................... 160
12.9 Atividades para este Capítulo ............................................................. 161
13 Um Pouco da API Swing e Acesso a Dados ............ 163
13.1 A Janela da Aplicação Exemplo ......................................................... 163
13.2 Implementando a Classe que Representa a Janela ........................... 164
13.2.1 Inicialização da Janela ....................................................................... 165
13.2.2 Criando o Painel que Conterá Componentes para a Informação
dos Dados ............................................................................................. 166
13.2.3 Criando o Painel que Conterá os Botões de Ação para o JFrame ... 167
13.2.4 Implementando Métodos de Acesso Necessários para a Janela. 168
13.2.5 Executando a Classe JFrame como Aplicação .............................. 169
13.3 Implementando o Comportamento da Classe Ouvidora ................ 169
13.4 Instalando os Recursos Necessários para Acesso a Banco
de Dados .................................................................................................. 170
13.5 Implementando a Conexão com o Banco de Dados ....................... 175
13.6 Implementando a Exception da Aplicação ....................................... 176
13.7 Implementando o Acesso a Dados ..................................................... 177
13.8 Obtendo os Dados Informados pelo Usuário na Janela ................. 178
13.9 Executando a Aplicação ...................................................................... 178
13.10 Atividades para este Capítulo ........................................................... 183
Referências ..................................................................... 185