Algoritmos Programacao

Prévia do material em texto

Algoritmos e Programação 
 
por 
 
Prof. Dr. Paulo Roberto Gomes Luzzardi 
 
 
 
facebook: Paulo Roberto Gomes Luzzardi 
WhatsApp: 91648037 
e-mail: pluzzardi@gmail.com e pluzzardi@yahoo.com.br 
e-mail (Senac): prgomesluzzardi@senacrs.edu.br 
DropBox: https://www.dropbox.com/sh/kea9kr4j2qttnjg/4xXvw0pvxX?m 
Hostinger: http://pluzzardi.w.pw e http://pluzzardi.zz.mu (Home Page) 
OS X Server (Apple): http://pluzzardi.no-ip.info:8080 (Home Page) 
 
Versão 2.03 
19-11-2014 
 
 
Bibliografia recomendada 
 
DEITEL, H. M. and DEITEL, P. J. Java: como programar, 8. ed.: São Paulo: Pearson, 2010 (ISBN 
85-363-0123-6). 
 
 
 
Pelotas, quarta-feira, 19 de novembro de 2014 (09:46 am) 
 2 
Sumário 
 
1. Projeto de Classes ..................................................................................................................................... 7	
  
1.1 Escrevendo uma classe em Java (Conceitos básicos) .................................................................... 7	
  
1.2 Sobrecarga de métodos ..................................................................................................................... 13	
  
1.3 Referência this ...................................................................................................................................... 13	
  
1.4 Lista de exercícios: Classes ................................................................................................................ 17	
  
2. Interface e Polimorfismo ....................................................................................................................... 32	
  
2.1 Interface ................................................................................................................................................. 32	
  
2.2 Polimorfismo ......................................................................................................................................... 35	
  
2.3 Lista de Exercícios: Interface e Polimorfismo ................................................................................. 38	
  
3. Herança em Java ...................................................................................................................................... 40	
  
3.1 Herança simples ................................................................................................................................... 40	
  
3.2 Controle de acesso na definição de uma classe derivada .......................................................... 41	
  
3.3 Tipos de acessos (especificadores de acesso) ............................................................................... 43	
  
3.4 Lista de exercícios: Herança .............................................................................................................. 46	
  
4. Métodos de entrada e saída de dados .............................................................................................. 51	
  
4.1 Entrada de dados via teclado ............................................................................................................ 51	
  
4.2 Saída de dados via tela ....................................................................................................................... 54	
  
4.3 Saída formatada (System.out.printf) ................................................................................................. 56	
  
4.4 Lista de Exercícios: Métodos de Entrada e Saída .......................................................................... 57	
  
5. Interfaces e Containers (Classes existentes em Java) ................................................................... 58	
  
5.1 Coleções (Collection FrameWork) ................................................................................................... 58	
  
5.2 Interfaces ............................................................................................................................................... 58	
  
5.3 Vector (Vetor) (Classe Obsoleta) ....................................................................................................... 59	
  
5.4 LinkedList (Lista Encadeada Simples) .............................................................................................. 64	
  
5.5 Arrays (array) ......................................................................................................................................... 69	
  
5.6 ArrayList (lista de array) ....................................................................................................................... 74	
  
5.6.1 Lista de exercícios: Vector, ArrayList e LinkedList ...................................................................... 76	
  
5.7 ArrayList bidimensional ...................................................................................................................... 84	
  
5.8 Strings (Cadeia de Caracteres) .......................................................................................................... 90	
  
5.8.1 Métodos para manipular Strings ................................................................................................... 91	
  
5.8.2 Lista de exercícios: Strings .............................................................................................................. 95	
  
5.9 Classe Object ........................................................................................................................................ 97	
  
5.10 Classe Iterator ................................................................................................................................... 100	
  
5.11 Classe LinkedHashSet ..................................................................................................................... 100	
  
5.12 Classe Genérica em Java ............................................................................................................... 102	
  
5.13 Fila Prioritária (PriorityQueue) ....................................................................................................... 104	
  
6. Listas Lineares: Pilhas, Filas e Deques ............................................................................................. 108	
  
6.1 Implementação de uma Pilha (Stack) ............................................................................................. 109	
  
6.2 Implementação de uma Fila (Queue) ............................................................................................ 114	
  
6.3 Implementação de um Deque (ArrayDeque) ............................................................................... 118	
  
6.4 Lista de Exercícios: Listas Lineares (Pilhas, Filas e Deques) ....................................................... 126	
  
7. Mapas (Maps) .......................................................................................................................................... 131	
  
7.1 Conceitos básicos sobre Mapas ..................................................................................................... 131	
  
7.2 Lista de Exercícios: Mapas ............................................................................................................... 136	
  
8. Processamento de fluxos de dados, caracteres e objetos (Arquivos) ................................... 138	
  
 3 
8.1 Métodos para manipular arquivos em Java ................................................................................. 140	
  
8.2 Abertura de um arquivo texto ......................................................................................................... 143	
  
8.3 Listar um diretório .............................................................................................................................. 144	
  
8.4 Manipulação de um arquivo de palavras ......................................................................................146	
  
8.5 Arquivo Texto ..................................................................................................................................... 149	
  
8.6 Lista de exercícios: Arquivos (Files) ................................................................................................ 157	
  
8.7 Acesso randômico em arquivos texto ........................................................................................... 160	
  
8.8 Arquivo binário de objetos em Java .............................................................................................. 161	
  
8.9 Leitura e gravação de objetos (registro) em Arquivos ............................................................... 163	
  
8.9.1 Gravação de objetos em um arquivo binário de objetos ....................................................... 164	
  
8.9.2 Leitura objetos em um arquivo binário de objetos ................................................................. 168	
  
9. Noções de desenvolvimento de aplicações em camadas (MVC) ............................................ 171	
  
9.1 Conceitos ............................................................................................................................................. 171	
  
9.2 Primeiro exemplo da utilização do MVC (ProgMVCPessoa) ..................................................... 172	
  
9.3 Segundo exemplo da utilização do MVC (ProgMVCPessoa2) .................................................. 175	
  
10. Conceitos gerais .................................................................................................................................. 181	
  
10.1 Como é calculado o hashcode no Java ...................................................................................... 181	
  
11. Lista Encadeada Simples em Java .................................................................................................. 182	
  
11.1 Lista Encadeada de Inteiros ........................................................................................................... 182	
  
11.2 Lista Encadeada Genérica (String, Integer ou Double) ............................................................ 188	
  
12. Lista Duplamente Encadeada em Java ......................................................................................... 192	
  
13. Classe entrada de inteiros e reais em Java sem erro na digitação ....................................... 202	
  
14. Alguns programas exemplos em Java .......................................................................................... 208	
  
14.1 Torre de Hanoi (Pilha - Stack) ........................................................................................................ 208	
  
14.2 Analisador de Expressões usando Stack .................................................................................... 214	
  
14.3 Calculadora Polonesa Reversa ...................................................................................................... 217	
  
14.4 Jogo Quebra-Cabeças ................................................................................................................... 220	
  
Anexos: Solução dos problemas propostos no Livro ...................................................................... 223	
  
Anexo 1.3 Solução da Lista: Classes ................................................................................................. 223	
  
1.3.1 ProgCirculo .................................................................................................................................. 223	
  
1.3.2 ProgPeso ...................................................................................................................................... 223	
  
1.3.3 ProgValidaCPF ............................................................................................................................ 224	
  
1.3.4 ProgDiaSemana .......................................................................................................................... 226	
  
1.3.5 ProgTestData ............................................................................................................................... 227	
  
1.3.6 ProgVetorSort .............................................................................................................................. 228	
  
1.3.7 ProgPessoa .................................................................................................................................. 231	
  
1.3.8 ProgPessoa2 ................................................................................................................................ 232	
  
1.3.9 ProgPessoas ................................................................................................................................ 234	
  
1.3.10 ProgAgenda .............................................................................................................................. 235	
  
Anexo 2.3 Solução da Lista: Interface e Polimorfismo ............................................................... 237	
  
2.3.1 ProgInterface_1 ........................................................................................................................... 237	
  
2.3.2 ProgInterface_2 ........................................................................................................................... 238	
  
2.3.2 ProgInterface_3 ........................................................................................................................... 240	
  
Anexo 3.4 Solução da Lista: Herança ............................................................................................... 241	
  
3.4.1 Herança (Primeiro) ...................................................................................................................... 241	
  
3.4.2 Herança (Segundo) .................................................................................................................... 242	
  
3.4.3 Herança (Terceiro) ...................................................................................................................... 243	
  
 4 
Anexo 4.4 Solução da Lista: Entrada e Saída Bufferizada .......................................................... 245	
  
4.4.1 ProgBuffer_1 ................................................................................................................................ 245	
  
4.4.2 ProgBuffer_2 ................................................................................................................................ 246	
  
Anexo 5.6.1 Solução da Lista: Vector, ArrayList e LinkedList .................................................... 247	
  
5.6.1.1 ProgVector_1 ........................................................................................................................... 247	
  
5.6.1.2 ProgVector_2 ........................................................................................................................... 247	
  
5.6.1.3 ProgVector_3 ........................................................................................................................... 248	
  
5.6.1.4 ProgVector_4 ........................................................................................................................... 249	
  
5.6.1.5 ProgVector_5 ........................................................................................................................... 250	
  
5.6.1.6 ProgVector_6 ........................................................................................................................... 251	
  
5.6.1.7 ProgVector_7 ........................................................................................................................... 252	
  
5.6.1.8 ProgVector_8 ...........................................................................................................................252	
  
5.6.1.9 ProgVector_9 ........................................................................................................................... 253	
  
5.6.1.10 ProgVector_10 ....................................................................................................................... 254	
  
5.6.1.11 ProgVector_11 ....................................................................................................................... 255	
  
5.6.1.12 ProgVector_12 ....................................................................................................................... 257	
  
5.6.1.13 ProgVector_13 ....................................................................................................................... 259	
  
5.6.1.14 ProgVector_14 ....................................................................................................................... 261	
  
5.6.1.15 ProgVector_15 ....................................................................................................................... 263	
  
5.6.1.16 ProgVector_16 ....................................................................................................................... 264	
  
Anexo 5.8.2 Solução da Lista: Strings .............................................................................................. 266	
  
5.8.2.1 ProgString_1 ............................................................................................................................ 266	
  
5.8.2.2 ProgString_2 ............................................................................................................................ 266	
  
5.8.2.3 ProgString_3 ............................................................................................................................ 267	
  
5.8.2.4 ProgString_4 ............................................................................................................................ 268	
  
5.8.2.5 ProgString_5 ............................................................................................................................ 268	
  
5.8.2.6 ProgString_6 ............................................................................................................................ 268	
  
5.8.2.7 ProgString_7 ............................................................................................................................ 269	
  
5.8.2.8 ProgString_8 ............................................................................................................................ 270	
  
Anexo 6.4 Solução da Lista: Listas Lineares ................................................................................... 271	
  
6.4.1 ProgLista_1 .................................................................................................................................. 271	
  
6.4.2 ProgLista_2 .................................................................................................................................. 271	
  
6.4.3 ProgLista_3 .................................................................................................................................. 272	
  
6.4.4 ProgLista_4 .................................................................................................................................. 273	
  
6.4.5 ProgLista_5 .................................................................................................................................. 273	
  
6.4.6 ProgLista_6 .................................................................................................................................. 274	
  
6.4.7 ProgLista_7 .................................................................................................................................. 275	
  
6.4.8 ProgLista_8 .................................................................................................................................. 276	
  
6.4.9 ProgLista_9 .................................................................................................................................. 276	
  
6.4.10 ProgLista_10 .............................................................................................................................. 277	
  
6.4.11 ProgLista_11 .............................................................................................................................. 278	
  
6.4.12 ProgLista_12 .............................................................................................................................. 278	
  
6.4.13 ProgLista_13 .............................................................................................................................. 279	
  
6.4.14 ProgLista_14 .............................................................................................................................. 280	
  
6.4.15 ProgLista_15 .............................................................................................................................. 281	
  
Anexo 7.2 Solução da Lista: Mapas .................................................................................................. 281	
  
7.2.1 ProgMap_1 .................................................................................................................................. 281	
  
 5 
7.2.2 ProgMap_2 .................................................................................................................................. 282	
  
7.2.3 ProgMap_3 .................................................................................................................................. 282	
  
7.2.4 ProgMap_4 .................................................................................................................................. 283	
  
7.2.5 ProgMap_5 .................................................................................................................................. 283	
  
Anexo 8.6 Solução da Lista: Arquivos (File) ................................................................................... 284	
  
8.6.1 ProgFile_1 .................................................................................................................................... 284	
  
8.6.2 ProgFile_2 .................................................................................................................................... 285	
  
8.6.3 ProgFile_3 .................................................................................................................................... 285	
  
8.6.4 ProgFile_4 .................................................................................................................................... 286	
  
8.6.5 ProgFile_5 .................................................................................................................................... 287	
  
8.6.6 ProgFile_6 .................................................................................................................................... 288	
  
8.6.7 ProgFile_7 .................................................................................................................................... 289	
  
8.6.8 ProgFile_8 .................................................................................................................................... 289	
  
8.6.9 ProgFile_9 .................................................................................................................................... 290	
  
8.6.10 ProgFile_10 ............................................................................................................................... 291	
  
8.6.11 ProgFile_11 ............................................................................................................................... 292	
  
8.6.12 ProgFile_12 ...............................................................................................................................293	
  
 
Lista de Figuras 
 
Figura 1: Estrutura de dados da classe Vetor .................................................................................... 8 
Figura 2: Exemplo de Herança em java .............................................................................................. 40 
Figura 3: Objetos gráficos: Linha e Retângulo ................................................................................. 50 
Figura 4: LinkedList - Lista Encadeada Simples ................................................................................. 65 
Figura 5: Representação gráfica de uma String ................................................................................ 90 
Figura 6: Representação de uma Fila e uma Pilha .......................................................................... 108 
Figura 7: Representação visual de um Deque ................................................................................. 118 
Figura 8: Representação gráfica de uma Tabela Hash (Hashtable) .............................................. 131 
Figura 9: Exemplo de um arquivo texto ........................................................................................... 138 
Figura 10: Editor hexadecimal mostrando o arquivo texto ........................................................... 139 
Figura 11: Editor hexadecimal mostrando o arquivo binário ........................................................ 139 
Figura 12: Exemplo de MVC .............................................................................................................. 172 
Figura 13: Exemplo de MVC .............................................................................................................. 176 
Figura 14: Lista Encadeada Simples ................................................................................................. 182 
Figura 15: Alocação de elementos na Memória RAM .................................................................... 183 
Figura 16: Lista Duplamente Encadeada ......................................................................................... 193 
Figura 17: Jogo Torre de Hanoi ....................................................................................................... 208 
Figura 18: Jogo Quebra-Cabeças ..................................................................................................... 220 
 
Lista de Tabelas 
 
Tabela 1: Tipos de Ícones .................................................................................................................... 53 
Tabela 2: Comandos de formatação .................................................................................................. 53 
Tabela 3: Especificadores de largura do campo .............................................................................. 54 
Tabela 4: Lista de Container ................................................................................................................ 55 
Tabela 5: Tipos de dados do Java ..................................................................................................... 172 
 
Legenda de Cores 
 
Vermelho <enter>: Entrada de dados do programa 
Azul: Saída do programa (Resultado do teste do Programa) 
Verde: Texto em destaque 
Marinho: Código em Java 
Preto: Texto normal 
Preto: Método em destaque 
Itálico: Palavra em Inglês 
Negrito: Texto em destaque 
Sublinado: Observações 
 
 
 7 
1. Projeto de Classes 
 
 A seguir são descritas algumas características da orientação a objetos em Java. 
1.1 Escrevendo uma classe em Java (Conceitos básicos) 
 
 O paradigma orientado à objetos possui cinco componentes básicos: objetos (possuem 
atributos e métodos), mensagens (chamadas aos métodos), classes (tipo de dado), instâncias 
(criação de objetos de uma classe específica – new – alocação de memória) e métodos (funções 
definidas pelo programador que manipulam os atributos). 
 
Objetos, mensagens, classes, instâncias e métodos 
 
Objetos são entidades lógicas que contém atributos (dados armazenados em variáveis) 
e métodos (funções) que manipulam estes dados. Um objeto pode ser definido através de um 
tipo de dado chamado classe (class). 
 
Resumo: 
 
a) Atributos: São as variáveis definidas/declaradas para cada objeto. 
b) Métodos: São as funções definidas pelo programador que servirão para manipular os 
atributos. 
c) Mensagens: São as chamadas dos métodos. 
d) Classe: É um tipo de dado definido por class. Uma classe não é um objeto, é sim uma 
descrição do objeto. 
e) Instância: Os objetos são instâncias de uma classe, ou seja, é criado um objeto 
pertencente a uma classe específica. O objeto pode responder chamadas dos métodos 
e armazenar informações nos atributos. 
 
Resumidamente, objetos são instâncias de classes que respondem as mensagens 
através dos métodos escritos pelo programador. 
 
 Uma linguagem de programação orientada à objetos pode suportar ou implementar seis 
propriedades: abstração, encapsulamento, polimorfismo, herança, associação (quando uma 
 8 
classe possui atributos do tipo de outra classe - agregação e composição) e classes abstratas e 
concretas. 
 
 Considere a seguinte estrutura de dados da Figura 1, onde há um vetor de “max” 
elementos e um atributo “n” que controla a quantidade de elementos presentes no vetor num 
dado momento. Esta estrutura é utilizada na classe Vetor definida a seguir. 
 
Figura 1: Estrutura de dados da classe Vetor 
 
Programa Exemplo: Classe “Vetor”, que possui a estrutura de dados exibida na Figura 1, e que 
possui os seguintes atributos: 
 
private int n; // número de elementos no vetor 
private final int[] vetor; // vetor que armazena os elementos 
private final int max; // máximo número de elementos no vetor 
 
// -------------------------------------------------------------------------------------------------------------------------------------------- Classe: Vetor.java 
 
package progvetor; 
 
public class Vetor { 
 // ------------------------------------- atributos da classe 
 private int n; 
 private final int[] vetor; 
 private final int max; 
 
 // ----------------------------------------- construtor 
 Vetor(int numeroElementos) { 
 max = numeroElementos; 
 vetor = new int[max]; // alocação de max número de elementos 
 n = 0; 
 } 
 
 // ----------------------------------------- add 
 public void add(int valor) { 
 if (n < max) { 
 vetor[n] = valor; 
 n++; 
 9 
 } else { 
 System.out.println("Erro: Excedeu Limite do Vetor"); 
 } 
 } 
 
 // --------------------------------------- exibe 
 public void exibe() { 
 System.out.print("Vetor: ["); 
 for (int i = 0; i < n; i++) { 
 System.out.print(vetor[i] + ", "); 
 } 
 System.out.println("\b\b]"); // apaga o último espaço em branco e a última vírgula 
 } // ‘\b’ retrocesso ou BackSpace 
 
 // ---------------------------------------------------- numeroElementosVetor 
 public int numeroElementosVetor() { 
 return(n); 
 } 
} 
 
// ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgVetor.java 
 
package progvetor; 
 
public class ProgVetor { 
 
 public static void main(String[] args) { 
 Vetor vetor = new Vetor(5); // 5 é o número de elementos no vetor estático da classe 
 
 vetor.add(10); 
 vetor.add(20); 
 vetor.add(30); 
 vetor.add(40); 
 vetor.add(50); 
 vetor.exibe(); 
 vetor.add(60); 
 vetor.exibe(); 
 System.out.println("Total de Elementos: " + vetor.numeroElementosVetor()); 
 } 
} 
 
Resultado do Programa: 
 
Vetor: [10,20, 30, 40, 50] 
Erro: Excedeu Limite do Vetor 
Vetor: [10, 20, 30, 40, 50] 
Total de Elementos: 5 
 
Tente implementar os seguintes métodos para a classe “Vetor”: 
 
 int valor = vetor.del(); 
 if (valor != -999) { 
 System.out.println("Valor Excluído: " + valor); 
 } else { 
 System.out.println("ERRO: Vetor Vazio"); 
 } 
 vetor.exibe(); 
 System.out.println("Total de Elementos: " + vetor.length()); 
 10 
 int pri = vetor.primeiro(); 
 System.out.println("Primeiro: " + pri); 
 int ult = vetor.ultimo(); 
 System.out.println("Último: " + ult); 
 int elemento = 20; 
 boolean flag = vetor.existe(elemento); 
 if (flag) { 
 System.out.println("Existe elemento: " + elemento); 
 } else { 
 System.out.println("Não Existe elemento 20"); 
 } 
 
Resultado do Programa: 
 
Vetor: [10, 20, 30, 40, 50] 
Erro: Excedeu Limite do Vetor 
Vetor: [10, 20, 30, 40, 50] 
Total de Elementos: 5 
Valor Excluído: 50 
Vetor: [10, 20, 30, 40] 
Total de Elementos: 4 
Primeiro: 10 
Último: 40 
Existe elemento: 20 
 
 Uma linguagem de programação orientada à objetos pode suportar e/ou implementar 
seis (6) propriedades: abstração, encapsulamento, polimorfismo, herança, associação 
(agregação e composição) e classes abstratas e concretas. 
 
Abstração 
 
 Objetos devem representar dados do mundo real. 
 
Encapsulamento (“encapsulação”) 
 
 Os objetos possuem internamente atributos e métodos agrupados no mesmo local, 
onde os métodos manipulam os atributos. Esta característica protege os dados (atributos) de 
alterações indevidas, somente os membros da classe podem acessar os atributos, desde que 
eles sejam privados (private) ou protegidos (protected) (caso das classes derivadas, que 
herdam o direito de acesso aos atributos). 
 
Polimorfismo (grego: “muitas formas”) 
 
É a capacidade de objetos diferentes reagirem segundo a sua função a uma ordem 
padrão. Significa que o nome de um objeto pode ser utilizado para vários propósitos 
ligeiramente diferentes, ou seja, “ ... uma interface, vários métodos ... ”. A característica de 
 11 
polimorfismo é utilizada principalmente em sobrecarga de métodos e operadores e classes 
abstratas, onde os métodos são declarados mas não definidos. Como tipos de polimorfismo 
tem-se: (a) Universal (inclusão [como em Java, por exemplo, List lista = new LinkedList();] e 
paramétrico [templates como em C++]) e (b) ad-hoc (sobrecarga de métodos e operadores). 
Java não possui sobrecarga de operadores. 
 
• Sobrecarga de Operador: Permite sobrecarregar operadores para realizar diferentes 
tipos de operações; 
 
• Sobrecarga de Método: Permite que um método retorne diferentes tipos de 
informações e aceite argumentos de vários tipos, inclusive com quantidade diferentes 
de argumentos; 
 
• Classes abstratas e concretas: Permite representar entidades e conceitos abstratos, 
sendo sempre uma superclasse (ou classe Base) e não permite ser instanciada, a classe 
abstrata apenas define um modelo (template) para uma funcionalidade e fornece uma 
implementação incompleta que é herdada pelas classes derivadas. Cada classe derivada 
implementa as funcionalidades da classe abstrata. Uma classe abstrata pode possuir 
métodos abstratos, mas os métodos são escritos nas classes derivadas concretas. 
Métodos abstratos definem apenas a forma do método não contendo nenhum tipo de 
código. Classes concretas implementam todos os métodos e podem ser instanciadas. 
 
Herança 
 
É o processo pelo qual uma classe de objetos pode adquirir as propriedades de outra 
classe de objetos, em outras palavras, um objeto herda as características de outro (herança 
simples) ou vários objetos (herança múltipla). A classe base é chamada de superclasse, 
enquanto a classe derivada pode ser chamada de subclasse. 
 
Associação 
 
É um vínculo que permite que objetos de uma ou mais classes se relacionem entre si. 
Esta associação pode ser: unária (o vínculo é entre objetos da mesma classe), binária (vínculo 
ocorre entre dois objetos de classes diferentes) ou múltipla (vínculo ocorre entre mais de 2 
 12 
objetos de classes diferentes). Cada associação pode possuir características de (a) 
cardinalidade ou multiplicidade (indica quantos objetos são possíveis em cada associação) e 
(b) navegação (existe a possibilidade dos objetos acessarem outros objetos da mesma 
associação). 
Uma associação pode ser de duas formas: agregação (relacionamento com 
características onde existe um grau menos intenso de coesão entre os elementos, pode haver 
um certo grau de independência) ou composição (relacionamento com características onde 
existe um alto grau de coesão e total grau de dependência entre os elementos). 
 
Classes Abstratas e Concretas 
 
É criada para representar entidades e conceitos abstratos. Uma classe abstrata é sempre 
uma superclasse ou classe base que não possui instâncias. Ela define apenas o modelo (como 
um template em C++) para uma funcionalidade e fornece uma implementação incompleta 
chamada de parte genérica sendo compartilhada por um conjunto de classes derivadas ou 
subclasses. Classes derivadas completam as funcionalida-des da classe abstrata anexando um 
comportamento específico. Classes abstratas possuem métodos abstratos. Esses métodos são 
implementados nas suas classes derivadas concretas com o objetivo de definir o 
comportamento específico. O método abstrato define apenas a assinatura do método não 
contendo nenhum código. Classes concretas implementam seus métodos e permitem 
instanciar objetos. Classes concretas não possuem métodos abstratos quando são classes 
derivadas de uma classe abstrata. 
 
Vantagens da Orientação à Objetos: (a) reutilização de código, (b) proteção aos dados; (c) 
organização ou estruturação dos dados em forma de classes e objetos; (d) sobrecarga de 
métodos e de operadores; (e) criação de pacotes de classes; (f) ter um conjunto de pacotes pré-
definidos (api’s: java2d, java3d, swing, awt, etc) e (g) permitir ao desenvolvedor criar seus 
próprios pacotes. 
API: Application Programming Interface ou Interface de Programação de Aplicativos. É um 
conjunto de padrões de programação que permitem a construção de aplicativos. 
 
 Em Java, o programador pode criar suas próprias classes. Uma classe possui duas partes 
distintas: atributos (variáveis) e métodos (funções ou procedimentos) que manipulam estes 
atributos. 
 13 
1.2 Sobrecarga de Métodos 
 
Java permite que métodos estáticos (e construtores) sejam sobrecarregados, desta 
forma, o retorno, número de argumentos ou mesmo o tipo de dados dos argumentos 
podem ser diferentes. Dependendo da chamada do método, o Java identifica qual método (ou 
construtor) sobrecarregado deve ser executado. Teoricamente, é uma especificação que pode 
ter várias implementações com características diferentes. 
 
// ---------------------------------------------------------------------------------------------------- Programa Principal: ProgSobreCarga.java 
 
package progsobrecarga; 
 
public class ProgSobreCarga { 
 
 public static void main(String[] args) { 
 imprime("Pelotas-RS"); 
 imprime(123.45); 
 imprime(123.45f); 
 imprime(123); 
 imprime('A'); 
 } 
 
 static void imprime(String s) { 
 System.out.println("String: " + s); 
 } 
 
 static void imprime(Double d) { 
 System.out.println("Double: " + d); 
 } 
 
 static void imprime(Float f) { 
 System.out.println("Float: " + f); 
 } 
 
 static void imprime(Integer i) { 
 System.out.println("Inteiro: " + i); 
 } 
 
 static void imprime(Character ch) { 
 System.out.println("Caracter:" + ch); 
 } 
} 
 
Resultado do Programa: 
 
String: Senac-RS 
Double: 123.45 
Float: 123.45 
Inteiro: 123 
Caracter: A 
 
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgPolimorfismo.java 
 
package progpolimorfismo; 
 
 14 
public class ProgPolimorfismo { 
 
 public static void main(String[] args) { 
 pixel(1, 2); 
 pixel(1, 2, 3); 
 pixel(1.0, 2.0, 3.0); 
 pixel('A', 'B', 'C'); 
 } 
 
 public static void pixel(int x, int y) { 
 System.out.printf("x = %d | y = %d\n", x, y); 
 } 
 
 public static void pixel(int x, int y, int z) { 
 System.out.printf("x = %d | y = %d | z = %d\n", x, y, z); 
 } 
 
 public static void pixel(double x, double y, double z) { 
 System.out.printf("x = %.2f | y = %.2f | z = %.2f\n", x, y, z); 
 } 
 
 public static void pixel(char x, char y, char z) { 
 System.out.printf("x = %c | y = %c | z = %c\n", x, y, z); 
 } 
} 
 
Resultado do Programa: 
 
x = 1 | y = 2 
x = 1 | y = 2 | z = 3 
x = 1,00 | y = 2,00 | z = 3,00 
x = A | y = B | z = C 
 
1.3 Referência this 
 
 Em Java, quando um método de uma classe é chamado, é passado automaticamente 
um argumento que é uma referência para o objeto que gerou a chamada. Esta referência é 
chamada this, ou seja, a referência this referencia o objeto que chamou o método. 
 
 Cada objeto tem acesso a uma referência a ele próprio, chamada this. Esta referência faz 
referências aos atributos e métodos de um objeto. 
 
Programa exemplo: Utilização da referência this em uma classe. 
 
// ------------------------------------------------------------------------------------------------------------------------------------- Classe: Data.java 
 
package progdata; 
 
import java.text.DecimalFormat; 
 
public class Data { 
 // ------------------------------------- atributos da classe 
 private int dia, mes, ano; 
 15 
 
 // ------------------------------------------------ construtor 
 Data(int dia, int mes, int ano) { 
 this.dia = dia; 
 this.mes = mes; 
 this.ano = ano; 
 } 
 
 // ------------------------------------------- sobrecarga do método toString 
 public String toString() { 
 DecimalFormat form = new DecimalFormat("00"); 
 String data = "Data: " + form.format(dia) + "/" + form.format(mes) + "/" + ano; 
 return (data); 
 } 
} 
 
// ---------------------------------------------------------------------------------------------------------- Programa Principal: ProgData.java 
 
package progdata; 
 
public class ProgData { 
 
 public static void main(String[] args) { 
 Data data = new Data(5, 8, 2014); 
 
 System.out.println(data); 
 } 
} 
 
Resultado do Programa: 
 
Data: 05/08/2014 
 
Solução do programa proposto acima: Classe “Vetor” e seus métodos. 
 
// -------------------------------------------------------------------------------------------------------------------------------------- Classe: Vetor.java 
 
package progvetor1; 
 
public class Vetor { 
 // --------------------------------------------- atributos da classe 
 private final int[] vetor; 
 private int n; 
 private final int max; 
 
 // ---------------------------------------------- construtor 
 Vetor(int numeroElementos) { 
 max = numeroElementos; 
 vetor = new int[max]; 
 n = 0; 
 } 
 
 // ----------------------------------------------- add 
 public void add(int valor) { 
 if (n < max) { 
 vetor[n] = valor; 
 n++; 
 } else { 
 16 
 System.out.println("Erro: Excedeu Limite do Vetor"); 
 } 
 } 
 
 // ------------------------------------------------ del 
 public int del() { 
 if (n != 0) { 
 int valor = vetor[n - 1]; 
 n--; 
 return (valor); 
 } else { 
 System.out.println("Erro: Vetor Vazio"); 
 return (-999); 
 } 
 } 
 
 // ------------------------------------------------- length 
 public int length() { 
 return (n); 
 } 
 
 // ------------------------------------------------- primeiro 
 public int primeiro() { 
 if (n != 0) { 
 return (vetor[0]); 
 } else { 
 return (-999); 
 } 
 } 
 
 // -------------------------------------------------- ultimo 
 public int ultimo() { 
 int ultimo = n - 1; 
 if (n != 0) { 
 return (vetor[ultimo]); 
 } else { 
 return (-999); 
 } 
 } 
 
 // ----------------------------------------------------- existe 
 public boolean existe(int elemento) { 
 for (int i = 0; i < n; i++) { 
 if (elemento == vetor[i]) { 
 return (true); 
 } 
 } 
 return (false); 
 } 
 
 // ----------------------------------------------------- exibe 
 public void exibe() { 
 System.out.print("Vetor: ["); 
 for (int i = 0; i < n; i++) { 
 System.out.print(vetor[i] + ", "); 
 } 
 System.out.println("\b\b]"); 
 } 
 
 17 
 // ------------------------------------------------------ numeroElementosVetor 
 public int numeroElementosVetor() { 
 return (n); 
 } 
} 
 
// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgVetor1.java 
 
package progvetor1; 
 
public class ProgVetor1 { 
 
 public static void main(String[] args) { 
 Vetor vetor = new Vetor(5); // 5 é o número de elementos do vetor estático da classe 
 
 vetor.add(10); 
 vetor.add(20); 
 vetor.add(30); 
 vetor.add(40); 
 vetor.add(50); 
 vetor.exibe(); 
 vetor.add(60); 
 vetor.exibe(); 
 System.out.println("Total de Elementos: " + vetor.numeroElementosVetor()); 
 int valor = vetor.del(); 
 if (valor != -999) { 
 System.out.println("Valor Excluído: " + valor); 
 } else { 
 System.out.println("ERRO: Vetor Vazio"); 
 } 
 vetor.exibe(); 
 System.out.println("Total de Elementos: " + vetor.length()); 
 int primeiro = vetor.primeiro(); 
 System.out.println("Primeiro: " + primeiro); 
 int ultimo = vetor.ultimo(); 
 System.out.println("Último: " + ultimo); 
 int elemento = 20; 
 boolean flag = vetor.existe(elemento); 
 if (flag) { 
 System.out.println("Existe elemento: " + elemento); 
 } else { 
 System.out.println("Não Existe elemento 20"); 
 } 
 } 
} 
 
1.4 Lista de exercícios: Classes 
 
1.4.1 Dado o seguinte programa principal, implemente a classe “Circulo” e seus métodos: 
 
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgCirculo.java 
 
package progcirculo; 
 
public class ProgCirculo { 
 
 public static void main(String[] args) { 
 Circulo circ = new Circulo(); 
 18 
 
 circ.setRaio(3); 
 circ.calculaArea(); 
 double area = circ.getArea(); 
 System.out.printf("Área: %.2f\n", area); 
 } 
} 
 
Observação: area = pi . raio2 onde pi é 3.1416 
 
Círculo 
double area, raio 
setRaio 
calculaArea 
getArea 
 Diagrama de classe 
 
Resultado do Programa: 
 
Área: 28,27 
 
1.4.2 Dado o seguinte programa principal, implemente a classe “PesoIdeal” e seus métodos: 
 
// ----------------------------------------------------------------------------------------------------------Programa Principal: ProgPeso.java 
 
package progpeso; 
 
public class ProgPeso { 
 
 public static void main(String[] args) { 
 PesoIdeal piHomem = new PesoIdeal('H', 1.67); 
 PesoIdeal piMulher = new PesoIdeal('m', 1.65); 
 
 piHomem.calculaPesoIdeal(); 
 System.out.printf("Peso Ideal Homem: %.2f\n", piHomem.getPesoIdeal()); 
 
 piMulher.calculaPesoIdeal(); 
 System.out.printf("Peso Ideal Mulher: %.2f\n", piMulher.getPesoIdeal()); 
 } 
} 
 
Resultado do Programa: Peso Ideal Homem: 63,41 
 Peso Ideal Mulher: 57,77 
 
Cálculo do Peso Ideal: PIH = 72,7 x altura – 58 
 PIM = 62,1 x altura – 44,7 
 
PesoIdeal 
double altura, pesoIdeal 
char sexo 
calculaPesoIdeal 
getPesoIdeal 
 Diagrama de classe 
 
1.4.3 Dado o seguinte programa principal, implemente a classe “CPF” e seus métodos: 
 
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgValidaCPF.java 
 19 
 
package progvalidacpf; 
 
public class ProgValidaCPF { 
 
 public static void main(String[] args) { 
 String s = "123456789"; 
 CPF cpf = new CPF(s); 
 
 int digitoVerificador = cpf.verificaCPF(); 
 System.out.printf("Digito verificador: %02d\n", digitoVerificador); 
 System.out.printf("CPF: %s-%02d\n", s , digitoVerificador); 
 } 
} 
 
Resultado do Programa: 
 
Digito verificador: 09 
CPF: 123456789-09 
 
CPF 
String cpf 
int digito 
verificaCPF 
 Diagrama de classe 
 
Como calcular os Dígitos do CPF: 
 
Entrada: CPF: 123456789 
 
1) Primeiramente pega-se os dígitos da base do CPF e se faz a soma da multiplicação individual dos dígitos, iniciando 
por 10 e indo até 2 como exemplificado abaixo: 
 
 1 2 3 4 5 6 7 8 9 
 x x x x x x x x x 
 10 9 8 7 6 5 4 3 2 
 -- -- -- -- -- -- -- -- -- 
 10 + 18 + 24 + 28 + 30 + 30 + 28 + 24 + 18 = 210 
2) O valor do primeiro dígito é o resultado da subtração de 11 pelo resto da divisão da soma acima por 11. Se este valor 
for 10 ou 11, o dígito é 0 (zero), do contrário é o próprio valor. No exemplo em questão o dígito encontrado é calculado 
conforme vê-se a seguir: 
 
11 - (210 % 11) = 10 
 
3) O cálculo do segundo dígito é feito da mesma forma que o primeiro, porém com os 9 dígitos da base do CPF e o 
primeiro dígito verificador encontrado, iniciando por 11 e indo até 2. 
 
 1 2 3 4 5 6 7 8 9 0 
 x x x x x x x x x x 
11 10 9 8 7 6 5 4 3 2 
-- -- -- -- -- -- -- -- -- -- 
11 + 20 + 27 + 32 + 35 + 36 + 35 + 32 + 27 + 0 = 255 
 
4) O valor do segundo dígito é o resultado da subtração de 11 pelo resto da divisão da soma acima por 11. Se este valor 
for 10 ou 11, o dígito é 0 (zero), do contrário é o próprio valor. No exemplo em questão o dígito encontrado é calculado 
conforme vê-se a seguir: 
 
11 - (255 % 11) = 9 
 
 20 
Saída: CPF válido é 123.456.789-09 ou 123456789-09 
 
1.4.4 Dado o seguinte programa, implemente a classe “DiaSemana” e seus métodos: 
 
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgDiaSemana.java 
 
package progdiasemana; 
 
public class ProgDiaSemana { 
 
 public static void main(String[] args) { 
 DiaSemana dia = new DiaSemana(10, 2, 1962); 
 
 dia.verificaDiaSemana(); 
 dia.exibeDiaSemana(); 
 } 
} 
 
Resultado do Programa: 
 
Dia da Semana: Sábado 
 
DiaSemana 
int dia, mes, ano 
String semama 
verificaDiaSemana 
exibeDiaSemana 
 Diagrama de classe 
 
 21 
Como calcular o Dia da Semana: 
 
Deve-se calcular o Dia do Século: 
 
Para qualquer cálculo com datas é essencial que se disponha do Dia do Século para a(s) data(s) em questão. O Dia do 
Século é o número de dias decorridos desde o início do século (1º de janeiro de 1901) até a data em questão. Se usa 
como referência 1901 porque a maioria das datas com as quais se trabalha ainda são do século passado. Lá por 2040 ou 
mais poderá se mudar para 2001. 
 
A fórmula (válida para datas entre 1901 e 2099) é a seguinte: 
 
numeroDias = (ano - 1901) * 365 + (ano - 1901) DIV 4 + dia + (mês - 1) * 31 - [(mês * 4 + 23) DIV 10] * [(mês + 12) DIV 15] 
+ [(4 - ano MOD 4) DIV 4] * [(mês + 12) DIV 15] 
 
Dados de Teste: Dia: 10 
 Mês: 2 
 Ano: 1962 
 
numeroDias = 22321 (para a data acima) 
 
Onde: DIV é a divisão inteira e MOD é o resto inteiro da divisão 
Verificação do Dia da Semana: Para saber o diaSemana basta dividir o numeroDias por 7 e entrar com o resto inteiro 
da divisão na tabela abaixo: 
0 Segunda 
1 Terça 
2 Quarta 
3 Quinta 
4 Sexta 
5 Sábado 
6 Domingo 
 
Resultado do Programa: (Saída) 
 
10/02/1962 é um(a) Sábado 
 
Observação: DIV é divisão inteira de dois números e MOD é o resto inteiro da divisão de dois números. 
 
1.4.5 Dado o seguinte programa principal, implemente a classe Data e seus métodos: 
 
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgTestData.java 
 
package progtestdata; 
 
public class ProgTestData { 
 
 public static void main(String[] args) { 
 Data data = new Data(); 
 
 data.setData(25, 8, 2014); 
 data.extenso(); 
 } 
} 
 
Resultado do Programa: 
 
Data: 25 de agosto de 2014 
 
 22 
Data 
int dia, mes, ano 
setData 
extenso 
 Diagrama de classe 
 
1.4.6 Implemente os métodos forcaBruta e bubleSort na classe “Vetor” vista anteriormente 
(Fonte: ProgVetor). 
 
// ------------------------------------------------------------------------------------------------------ Programa Principal: ProgVetorSort.java 
 
package progvetorsort; 
 
public class ProgVetorSort { 
 
 public static void main(String[] args) { 
 Vetor vetor = new Vetor(5); 
 
 vetor.add(40); 
 vetor.add(20); 
 vetor.add(30); 
 vetor.add(50); 
 vetor.add(10); 
 vetor.exibe(); 
 vetor.add(60); 
 vetor.exibe(); 
 vetor.forcaBruta(); 
 vetor.exibe(); 
 vetor.bubbleSort(); 
 vetor.exibe(); 
 } 
} 
 
Resultado do Programa: 
 
Vetor: [40 20 30 50 10] 
ERRO: Excedeu o Limite do Vetor 
Vetor: [40 20 30 50 10] 
Vetor: [10 20 30 40 50] 
Vetor: [10 20 30 40 50] 
 
1.4.7 Dado o seguinte programa principal, implemente a classe “Pessoa” e seus métodos. 
 
// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoa.java 
 
package progpessoa; 
 
public class ProgPessoa { 
 
 public static void main(String[] args) { 
 Pessoa p1 = new Pessoa(); 
 Pessoa p2 = new Pessoa(); 
 Pessoa p3 = new Pessoa(); 
 
 p1.setDados("Paulo Roberto", 1962, 'm'); 
 p2.setDados("Renato Luis", 1965, 'm'); 
 p3.setDados("Francisco Carlos", 1959, 'm'); 
 p1.calculaIdade(); 
 23 
 p2.calculaIdade(); 
 p3.calculaIdade(); 
 p1.exibePessoa(); 
 p2.exibePessoa(); 
 p3.exibePessoa(); 
 } 
} 
 
Resultado do Programa: 
 
Nome: Paulo Roberto 
Idade: 52 ano(s) 
Sexo: Masculino 
Nome: Renato Luis 
Idade: 49 ano(s) 
Sexo: Masculino 
Nome: Francisco Carlos 
Idade: 55 ano(s) 
Sexo: Masculino 
 
Pessoa 
String nome 
int ano 
int idade 
char sexo 
setDados 
calculaIdade 
exibePessoa 
 Diagrama de classe 
 
1.4.8 Dado o seguinte programa principal, implemente a classe “Pessoa” e seus métodos. 
 
// -------------------------------------------------------------------------------------------------------Programa Principal: ProgPessoa2.java 
 
package progpessoa2; 
 
public class ProgPessoa2 { 
 
 public static void main(String[] args) { 
 Pessoa [] pessoa = new Pessoa[3]; 
 
 pessoa[0] = new Pessoa(); 
 pessoa[0].setDados("Paulo Roberto", 1962, 'm'); 
 pessoa[0].calculaIdade(); 
 pessoa[0].exibePessoa(); 
 
 pessoa[1] = new Pessoa(); 
 pessoa[1].setDados("Renato Luis", 1965, 'm'); 
 pessoa[1].calculaIdade(); 
 pessoa[1].exibePessoa(); 
 
 pessoa[2] = new Pessoa(); 
 pessoa[2].setDados("Francisco Carlos", 1959, 'm'); 
 pessoa[2].calculaIdade(); 
 pessoa[2].exibePessoa(); 
 } 
} 
 
 24 
Resultado do Programa: 
 
Nome: Paulo Roberto 
Idade: 52 ano(s) 
Sexo: Masculino 
Nome: Renato Luis 
Idade: 49 ano(s) 
Sexo: Masculino 
Nome: Francisco Carlos 
Idade: 55 ano(s) 
Sexo: Masculino 
 
Pessoa 
String nome 
int ano 
int idade 
char sexo 
setDados 
calculaIdade 
exibePessoa 
 Diagrama de classe 
 
1.4.9 Dado o seguinte programa principal, implemente a classe “Pessoa” e seus métodos. 
 
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgPessoas.java 
 
package progpessoas; 
 
public class ProgPessoas { 
 
 public static void main(String[] args) { 
 Pessoa pessoa = new Pessoa(7); 
 
 pessoa.insereDados("Beatriz", 11); 
 pessoa.insereDados("Debora", 13); 
 pessoa.insereDados("Fátima", 15); 
 pessoa.insereDados("Geni", 16); 
 pessoa.insereDados("Carla", 12); 
 pessoa.insereDados("Eva", 14); 
 pessoa.insereDados("Ana", 10); 
 pessoa.exibeDados(); 
 pessoa.sort(); 
 pessoa.exibeDados(); 
 } 
} 
 
Resultado do Programa: 
 
Lista de Pessoas 
Nome: Beatriz Idade: 11 
Nome: Debora Idade: 13 
Nome: Fátima Idade: 15 
Nome: Geni Idade: 16 
Nome: Carla Idade: 12 
Nome: Eva Idade: 14 
Nome: Ana Idade: 10 
Lista de Pessoas 
Nome: Ana Idade: 10 
Nome: Beatriz Idade: 11 
 25 
Nome: Carla Idade: 12 
Nome: Debora Idade: 13 
Nome: Eva Idade: 14 
Nome: Fátima Idade: 15 
Nome: Geni Idade: 16 
 
Pessoa 
String [] nome 
int [] idade 
int n 
int max 
insereDados 
exibeDados 
sort 
 Diagrama de classe 
 
1.4.10 Dado o seguinte programa principal, implemente a classe “Agenda” e seus métodos. 
 
// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgAgenda.java 
 
package progagenda; 
 
public class ProgAgenda { 
 
 public static void main(String[] args) { 
 Agenda agenda = new Agenda(5); 
 
 agenda.insereTelefone("Ana", "99811234"); 
 agenda.insereTelefone("Beatriz", "99812345"); 
 agenda.insereTelefone("Carla", "99813456"); 
 agenda.insereTelefone("Debora", "99814567"); 
 agenda.insereTelefone("Eva", "99815678"); 
 agenda.insereTelefone("Fátima", "99816789"); 
 String fone = "99815678"; 
 String nome = agenda.consultaNome(fone); 
 if (nome.compareTo("") != 0) { 
 System.out.println("Nome: " + nome + " - Telefone: " + fone); 
 } else { 
 System.out.println("ERRO: Usuário não Encontrado"); 
 } 
 fone = "99810123"; 
 nome = agenda.consultaNome(fone); 
 if (nome.compareTo("") != 0) { 
 System.out.println("Nome: " + nome + " - Telefone: " + fone); 
 } else { 
 System.out.println("ERRO: Usuário não Encontrado"); 
 } 
 } 
} 
 
Resultado do Programa: 
 
ERRO: Excedeu limite da Agenda 
Nome: Eva - Telefone: 99815678 
ERRO: Usuário não Encontrado 
 
Agenda 
String [] nome 
 26 
String [] fone 
int n 
int max 
insereTelefone 
consultaNome 
 Diagrama de classe 
 
1.4.11 Dado o seguinte programa principal, implemente a classe “Calculadora” e seus 
métodos. 
 
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgCalculadora.java 
 
package progcalculadora; 
 
public class ProgCalculadora { 
 
 public static void main(String[] args) { 
 Calculadora calc = new Calculadora(); 
 
 calc.entradaDados(); 
 calc.operaCalculadora(); 
 calc.exibeResultadoCalculadora(); 
 } 
} 
 
Observação: A calculadora deve ter as seguintes operações: 
 
• [+] adição 
• [-] subtração 
• [*] multiplicação 
• [/] divisão 
• [R] Raiz Quadrada 
• [P] Potência 
• [S] Seno 
• [C] Cosseno 
• [T] Tangente 
 
Calculadora 
double x 
double y 
char operador 
double resposta 
entradaDados 
operaCalculadora 
exibeResultadoCalculadora 
 Diagrama de classe 
 
Exemplo para testar o programa: 
 
Digite um Valor: 3 <enter> 
Operação [+-*/RrPpSsCcTt]: + <enter> 
Digite outro Valor: 4 <enter> 
Primeiro Valor: 3.0 
Operador: [Adição] 
Segundo Valor : 4.0 
Resultado da Operação: 7.0 
 
 27 
Exemplo da definição de uma classe “Data”: 
 
// -------------------------------------------------------------------------------------------------------------------------------------------- Classe: Data.java 
 
package progtestadata; 
 
public class Data { 
 // ------------------------------ atributos da classe 
 private final int dia; 
 private final int mes; 
 private final int ano; 
 
 // ----------------------------------------------------- construtor da classe 
 public Data(int dia, int mes, int ano) { 
 this.dia = dia; 
 this.mes = mes; 
 this.ano = ano; 
 } 
 
 // ------------------------------------------------------------------------------------------ sobrecarga do método toString 
 @Override // método “toString” sobrecarregado 
 public String toString() { 
 return("Data: " + this.dia + "/" + this.mes + "/" + this.ano); 
 } 
} 
 
Programa exemplo: Programa que utiliza a classe “Data” definida anteriormente: 
 
// ----------------------------------------------------------------------------------------------------- Programa Principal: ProgTestaData.java 
 
package progtestadata; 
 
public class ProgTestaData { 
 
 public static void main(String[] args) { 
 Data data = new Data(16, 3, 2010); // construtor irá receber 3 argumentos 
 
 System.out.println(data); 
 } 
} 
 
Resultado do Programa: 
 
Data: 16/3/2010 
 
Exemplo da definição de uma classe “Calculadora”: 
 
// -------------------------------------------------------------------------------------------------------------------- Classe: Calculadora.java 
 
package progcalculadora; 
 
import java.util.Scanner; 
 
public class Calculadora { 
 // ------------------------ atributos da classe 
 private double x; 
 private double y; 
 private double resultado; 
 28 
 private char operador; 
 
 // ------------------------ construtor 
 
 // --------------------------------------- métodos públicos da classe 
 public void entradaDados() { 
 Scanner input = new Scanner(System.in); 
 System.out.print("Digite um Valor: "); 
 String s = input.nextLine(); 
 s = s.replaceAll("[^0-9\\-.]", ""); // eliminação de letras digitadas de forma indevida 
 x = Double.parseDouble(s); // que não podem ser convertidas para double 
 do { 
 System.out.print("Operação [+-*/RrPpSsCcTt]: "); 
 s = input.nextLine(); 
 operador = s.charAt(0); 
 } while (!strChr("+-*/RrPpSsCcTt", operador)); 
 if (strChr("+-*/Pp", operador)) { 
 System.out.print("Digite outro Valor: "); 
 s = input.nextLine(); 
 s = s.replaceAll("[^0-9\\-.]",""); // eliminação de letras digitadas de forma indevida 
 y = Double.parseDouble(s); // que não podem ser convertidas para double 
 } 
 } 
 
 public void operaCalculadora() { 
 switch (operador) { 
 case '+': 
 resultado = add(); 
 break; 
 case '-': 
 resultado = sub(); 
 break; 
 case '*': 
 resultado = mul(); 
 break; 
 case '/': 
 resultado = div(); 
 break; 
 case 'P': 
 case 'p': 
 resultado = pot(); 
 break; 
 case 'R': 
 case 'r': 
 resultado = raiz(); 
 break; 
 case 'S': 
 case 's': 
 resultado = sen(); 
 break; 
 case 'C': 
 case 'c': 
 resultado = cos(); 
 break; 
 case 'T': 
 case 't': 
 resultado = tan(); 
 break; 
 } 
 29 
 } 
 
 public void exibeResultadoCalculadora() { 
 String nomeOperador; 
 
 System.out.println("Primeiro Valor: " + x); 
 switch (operador) { 
 case '+': nomeOperador = "Adição"; 
 break; 
 case '-': nomeOperador = "Subtração"; 
 break; 
 case '*': nomeOperador = "Multiplicação"; 
 break; 
 case '/': nomeOperador = ("Divisão"); 
 break; 
 case 'R': 
 case 'r': nomeOperador = "Raiz Quadrada"; 
 break; 
 case 'P': 
 case 'p': nomeOperador = "Potência"; 
 break; 
 case 'S': 
 case 's': nomeOperador = "Seno"; 
 break; 
 case 'C': 
 case 'c': nomeOperador = "Cosseno"; 
 break; 
 case 'T': 
 case 't': nomeOperador = "Tangente"; 
 break; 
 default: nomeOperador = "Operador Inválido"; 
 } 
 System.out.printf("Operação realizada: [%s]\n", nomeOperador); 
 System.out.println("Segundo Valor : " + y); 
 System.out.println("Resultado da Operação: " + resultado); 
 } 
 
 // ------------------------------- métodos privados da classe 
 private double add() { 
 return (x + y); 
 } 
 
 private double sub() { 
 return (x - y); 
 } 
 
 private double mul() { 
 return (x * y); 
 } 
 
 private double div() { 
 return (x / y); 
 } 
 
 private double pot() { 
 return (Math.pow(x, y)); 
 } 
 
 private double raiz() { 
 30 
 return (Math.sqrt(x)); 
 } 
 
 private double sen() { 
 double rads = converteRadianos(x); 
 return (Math.sin(rads)); 
 } 
 
 private double cos() { 
 double rads = converteRadianos(x); 
 return (Math.cos(rads)); 
 } 
 
 private double tan() { 
 double rads = converteRadianos(x); 
 return (Math.tan(rads)); 
 } 
 
 // ----------------------------------------------------------------------- métodos estáticos da classe 
 private static boolean strChr(String s, char ch) { 
 int n = s.length(); 
 for (int i = 0; i < n; i++) { 
 if (s.charAt(i) == ch) { 
 return (true); 
 } 
 } 
 return (false); 
 } 
 
 private static double converteRadianos(double graus) { 
 double rads = Math.PI * graus / 180.0; 
 return (rads); 
 } 
} 
 
Programa exemplo: Utiliza a classe “Calculadora” e seus métodos definidos acima: 
 
// -------------------------------------------------------------------------------------------------- Programa Principal: ProgCalculadora.java 
 
package progcalculadora; 
 
public class ProgCalculadora { 
 
 public static void main(String[] args) { 
 Calculadora calc = new Calculadora(); // classe não recebe argumentos, não é necessário ela ter construtor 
 
 calc.entradaDados(); 
 calc.operaCalculadora(); 
 calc.exibeCalculadora(); 
 } 
} 
 
Programa exemplo: Mostra outra forma de utilizar a função “strChr” oriunda da linguagem de 
programação C e C++ utilizando o método “indexOf” do Java. 
 
// -------------------------------------------------------------------------------------------------------- Programa Principal: ProgstrChr.java 
 
 31 
package progstrchr; 
 
import java.util.Scanner; 
 
public class ProgstrChr { 
 
 public static void main(String[] args) { 
 Scanner entrada = new Scanner(System.in); 
 String nome, s; 
 
 do { 
 System.out.print("Nome: "); 
 nome = entrada.nextLine(); 
 int n = nome.length(); 
 System.out.println(nome + " seu nome tem " + n + " caracteres"); 
 do { 
 System.out.print("Continua [S/N]? " ); 
 s = entrada.nextLine(); 
 } while ("SsNn".indexOf(s) == -1); 
 } while ("Nn".indexOf(s) == -1); // ou ... } while ("S".equalsIgnoreCase(s)); 
 } 
} 
 
Exemplo para testar o programa: 
 
Nome: Paulo Roberto Gomes Luzzardi <enter> 
Paulo Roberto Gomes Luzzardi seu nome tem 28 caracteres 
Continua [S/N]? N <enter> 
 
Modificadores de Acesso: 
 
• public: Os atributos e métodos tornam-se públicos, ou seja, qualquer outro método 
pode chamar ou utilizar estes atributos e/ou métodos. 
• private: Somente os métodos da classe (membros) da classe podem chamar ou utilizar 
atributos ou métodos privados. 
• protected: Utilizado em herança simples de classe (construção de subclasses), ou seja, 
uma subclasse herda todos os atributos e métodos da classe base (superclasse). Deixa 
acessível os atributos e/ou métodos para todas as outras classes (classe base) e 
subclasses (classe derivada). 
 
 32 
2. Interface e Polimorfismo 
 
2.1 Interface 
 
Uma interface é uma especificação que define um determinado conjunto de métodos 
que serão implementados nas classes desta interface. Para uma interface ser integralmente 
abstrata, seus métodos devem ser definidos como abstract e as variáveis por padrão são 
sempre constantes (static final). 
Uma interface é definida através da palavra reservada interface e uma classe para 
implementar uma interface usa a palavra reservada implements. 
Como Java não possui herança múltipla, a implementação de interfaces supram esta 
carência, como uma classe só pode herdar apenas uma vez, pode-se implementar inúmeras 
interfaces. As classes que implementam uma interface terão obrigatoriamente que ter todos os 
métodos da interface ou se transformar em uma classe abstrata. 
// ------------------------------------------------------------------------------------------------------------- Programa Principal: ProgInterface.java 
 
package proginterface; 
 
public class ProgInterface { 
 
 public static void main(String[] args) { 
 Homem homem = new Homem("Paulo Roberto"); 
 Mulher mulher = new Mulher("Adriane Maria"); 
 
 homem.exibeNome(); 
 homem.exibeSexo(); 
 mulher.exibeNome(); 
 mulher.exibeSexo(); 
 } 
} 
 
// ------------------------------------------------------------------------------------------------------------------------------- Classe: Pessoa.java 
 
package proginterface; 
 
public interface Pessoa { 
 public abstract void exibeNome(); 
 public abstract void exibeSexo(); 
} 
 
// ------------------------------------------------------------------------------------------------------------------------------ Classe: Homem.java 
 
package proginterface; 
 
publicclass Homem implements Pessoa { 
 33 
 // --------------------------------------------- atributos da classe 
 private final String nome; 
 private static final char sexo = 'm'; 
 
 Homem(String nome) { 
 this.nome = nome; 
 } 
 
 @Override // método “exibeNome” sobrecarregado 
 public void exibeNome() { 
 System.out.println("Homem: " + nome); 
 } 
 
 @Override // método “exibeSexo” sobrecarregado 
 public void exibeSexo() { 
 System.out.println("Sexo: Masculino -> " + sexo); 
 } 
} 
 
// --------------------------------------------------------------------------------------------------------------------------------------- Classe: Mulher.java 
 
package proginterface; 
 
public class Mulher implements Pessoa{ 
 // ------------------------------------------------- atributos da classe 
 private final String nome; 
 private static final char sexo = 'f'; 
 
 Mulher(String nome) { 
 this.nome = nome; 
 } 
 
 @Override // método “exibeNome” sobrecarregado 
 public void exibeNome() { 
 System.out.println("Mulher: " + nome); 
 } 
 
 @Override // método “exibeSexo” sobrecarregado 
 public void exibeSexo() { 
 System.out.println("Sexo: Feminino -> " + sexo); 
 } 
} 
 
Resultado do Programa: 
 
Homem: Paulo Roberto 
Sexo: Masculino -> f 
Mulher: Adriane Maria 
Sexo: Feminino -> m 
 
// --------------------------------------------------------------------------------------------------------------- Programa Principal: ProgPixel.java 
 
package progpixel; 
 
public class ProgPixel { 
 
 public static void main(String[] args) { 
 Pixel2D pixel2D = new Pixel2D(3, 4); 
 Pixel3D pixel3D = new Pixel3D(5, 6, 7); 
 34 
 
 pixel2D.exibe(); 
 pixel2D.setX(7); 
 pixel2D.setY(8); 
 pixel2D.exibe(); 
 
 pixel3D.exibe(); 
 pixel3D.setX(1); 
 pixel3D.setY(2); 
 pixel3D.setZ(3); 
 pixel3D.exibe(); 
 } 
} 
 
// ---------------------------------------------------------------------------------------------------------------------------------------- Interface: Pixel.java 
 
package progpixel; 
 
public interface Pixel { 
 public abstract void setX(int x); 
 public abstract void setY(int y); 
 public abstract void setZ(int z); 
 public abstract void exibe(); 
} 
 
// ---------------------------------------------------------------------------------------------------------------------------------------- Classe: Pixel2D.java 
 
package progpixel; 
 
public class Pixel2D implements Pixel { 
 private int x; 
 private int y; 
 
 Pixel2D(int x, int y) { 
 this.x = x; 
 this.y = y; 
 } 
 
 @Override 
 public void setX(int x) { 
 this.x = x; 
 } 
 
 @Override 
 public void setY(int y) { 
 this.y = y; 
 } 
 
 @Override 
 public void setZ(int z) { 
 } 
 
 @Override 
 public void exibe() { 
 System.out.printf("x = %d | y = %d\n", x, y); 
 } 
} 
 
// ---------------------------------------------------------------------------------------------------------------------------------------- Classe: Pixel3D.java 
 35 
package progpixel; 
 
public class Pixel3D implements Pixel { 
 private int x; 
 private int y; 
 private int z; 
 
 Pixel3D(int x, int y, int z) { 
 this.x = x; 
 this.y = y; 
 this.z = z; 
 } 
 
 @Override 
 public void setX(int x) { 
 this.x = x; 
 } 
 
 @Override 
 public void setY(int y) { 
 this.y = y; 
 } 
 
 @Override 
 public void setZ(int z) { 
 this.z = z; 
 } 
 
 @Override 
 public void exibe() { 
 System.out.printf("x = %d | y = %d | z = %d\n", x, y, z); 
 } 
} 
 
Resultado do Programa: 
 
x = 3 | y = 4 
x = 7 | y = 8 
x = 5 | y = 6 | z = 7 
x = 1 | y = 2 | z = 3 
 
2.2 Polimorfismo 
 
Conforme dito anteriormente, Polimorfismo, do grego: “muitas formas”, é a capacidade 
de objetos diferentes reagirem segundo a sua função a uma ordem padrão. Significa que o 
nome de um objeto pode ser utilizado para vários propósitos ligeiramente diferentes, ou seja, “ 
... uma interface, vários métodos ... ”. A característica de polimorfismo é utilizada principalmente 
em sobrecarga de métodos e operadores e classes abstratas, onde os métodos são 
declarados abstratos mas não definidos. Como tipos de polimorfismo tem-se: (a) Universal 
(inclusão [como em Java, por exemplo, List lista = new LinkedList();] e paramétrico [templates 
 36 
como em C++]) e (b) ad-hoc (sobrecarga de métodos e operadores). Java não possui 
sobrecarga de operadores. 
 
• Sobrecarga de Operador: Permite sobrecarregar operadores para realizar diferentes 
tipos de operações; 
 
• Sobrecarga de Método: Permite que um método retorne diferentes tipos de 
informações e aceite argumentos de vários tipos, inclusive com quantidade diferentes 
de argumentos; 
 
• Classes abstratas e concretas: Permite representar entidades e conceitos abstratos, 
sendo sempre uma superclasse (ou classe Base) e não permite ser instanciada, a classe 
abstrata apenas define um modelo (template) para uma funcionalidade e fornece uma 
implementação incompleta que é herdada pelas classes derivadas. Cada classe derivada 
implementa as funcionalidades da classe abstrata. Uma classe abstrata pode possuir 
métodos abstratos, mas os métodos são escritos nas classes derivadas concretas. 
Métodos abstratos definem apenas a forma do método não contendo nenhum tipo de 
código. Classes concretas implementam todos os métodos e podem ser instanciadas. 
 
Polimorfismo é o princípio no qual duas ou mais classes derivadas de uma mesma classe 
base podem implementar métodos que têm a mesma especificação, mas tem comportamentos 
diferentes, especializadas para cada uma das classes derivadas, utilizando uma referência a cada 
um dos objetos da classe base. 
Polimorfismo significa várias formas, onde um objeto pode se comportar de formas 
ligeiramente diferentes ao receber uma mensagem. Através do mecanismo de sobrecarga, dois 
métodos de uma classe podem ter o mesmo nome, desde que suas implementações sejam 
diferentes, entretanto isso não é considerado polimorfismo em Java. 
No polimorfismo é necessário que os métodos tenham exatamente a mesma especificação, 
sendo utilizado um mecanismo de redefinição de métodos nas classes derivadas. 
// ------------------------------------------------------------------------------------------------------- Programa Principal: ProgPolimorfismo.java 
 
package progpolimorfismo; 
 
 37 
public class ProgPolimorfismo { 
 
 public static void main(String[] args) { 
 Pessoa homem = new Homem(1.64, 'm'); 
 System.out.printf("Peso Ideal: %.2f (%s)\n", homem.calculaPesoIdeal(), homem.getSexo()); 
 Pessoa mulher = new Mulher(1.64, 'f'); 
 System.out.printf("Peso Ideal: %.2f (%s)\n", mulher.calculaPesoIdeal(), mulher.getSexo()); 
 } 
} 
 
// ------------------------------------------------------------------------------------------------------- Classe Base: Pessoa.java 
 
package progpolimorfismo; 
 
abstract class Pessoa { 
 
 protected Double altura; 
 protected Character sexo; 
 
 public abstract Double calculaPesoIdeal(); 
 public abstract String getSexo(); 
} 
 
// ------------------------------------------------------------------------------------------------------- Classe Derivada: Homem.java 
 
package progpolimorfismo; 
 
class Homem extends Pessoa { 
 Homem(Double altura, Character sexo) { 
 this.altura = altura;