Arquivo de Programação 1

Prévia do material em texto

PROGRAMAÇÃO I
Professor Alessandro Larangeiras
 
UNIDADE 1: INTRODUÇÃO À LINGUAGEM DE PROGRAMAÇÃO
1.1 Características da linguagem Java
1.2 Plataforma Java
1.3 Ambiente de programação
1.4 Tipos de dados
1.5 Constantes e variáveis
1.6 Operadores e expressões
1.7 Comandos de controle de fluxo
1.8 Entrada e Saída de dados via console e com JOptionPane
1.9 Conversão de tipos
CONTEÚDO
 
UNIDADE 2: CONCEITOS DE ORIENTAÇÃO A OBJETOS
2.1 Classes e Objetos
2.1.1 Atributos, métodos e construtor
2.1.2 Encapsulamento
2.1.3 Sobrecarga de métodos e de construtores
2.1.4 Métodos e atributos estáticos
2.1.5 Classes pré-definidas: Math e String
2.1.6 Vetor
2.1.7 Relacionamento entre objetos
2.2 Herança e polimorfismo
2.3 Classe Abstrata
2.4 Interface
CONTEÚDO
 
UNIDADE 3: TRATAMENTO DE EXCEÇÕES
3.1 Hierarquia de classes
3.2 Como capturar exceções
3.3 Uso de throws e throw
UNIDADE 4: COLEÇÕES
4.1 Introdução
4.2 ArrayList
4.3 Classes Wrapper
4.4 Generics
CONTEÚDO
 
Programação de computador é o processo de se escrever [um] […] 
conjunto de instruções para o computador seguir, a fim de produzir um 
resultado desejado.
Uma linguagem de programação é um conjunto de palavras, símbolos e 
códigos que permitem a um programador comunicar instruções a um 
computador.
SHELLY, 2006, p. 2.
 
Paradigma de programação é um 
ESTILO OU “MODO” DE PROGRAMAR.
[…] Uma das características de uma 
linguagem [de programação] é o seu 
SUPORTE a paradigmas de programação 
em particular.
TOAL, 2018.
 
Linguagens de programação por paradigma.
 
[…] [O paradigma] procedural foi a abordagem de fato dos 
primórdios da programação. Nele, o código é modularizado 
com base em procedimentos de um sistema.
Por exemplo, no desenvolvimento de uma aplicação de 
bibliotecas, consideraríamos procedimentos tais como 
ENTRADA E SAÍDA DE LIVROS, RESERVA DE 
LIVROS, CATALOGAÇÃO DE LIVROS e assim por 
diante.
A solução de problemas envolveria a análise desses 
procedimentos, em termos de tarefas processuais executadas, e a 
elaboração de um sistema cuja representação se baseasse no 
fluxo processual desses procedimentos.
POO; KIONG; ASHOK, 2008, p. 1.
 
// Código em C++, no paradigma procedural.
// ...
int main(int argc, char* argv)
{
 bool isRunning = true;
 int menuItem = 0;
 while(isRunning)
 {
 cout << "Escolha um item do menu: ";
 menuItem >> cin;
 switch(menuItem)
 {
 case 1:
 reservaLivro();
 break;
 case 2:
 entraLivro();
 break;
 case 3:
 saiLivro();
 break;
 case 4:
 catalogaLivro();
 break;
 case 5:
 isRunning = false; // Encerra o programa.
 break;
 }
 }
 
 return 0;
}
 
[…] [O paradigma] orientado a objetos, por outro 
lado, [envolve a modelagem de] [...] objetos e 
suas interações no âmbito do problema, e a elaboração 
de um sistema baseado nestes objetos e em suas interações.
POO; KIONG; ASHOK, 2008, p. 1.
Do ponto de vista do programador, programar orientado a objetos 
significa que você se concentrará em construir classes para 
representar os dados da sua aplicação, em vez de solucionar um 
problema por meio de um conjunto de procedimentos que devem 
ser seguidos em determinada ordem[, como ocorre na 
programação procedural].
HOLMES; JOYCE, 2001, p. 2.
 
// Código em Java, no paradigma orientado a objetos.
public class Livro {
private String titulo;
private String autor;
private String editora;
public Livro(String _titulo, String _autor, String _editora) {
titulo = _titulo;
autor = _autor;
editora = _editora;
}
public void reserva() {
// ...
}
public void entra() {
// ...
}
public void sai() {
// ...
}
public void cataloga() {
// ...
}
}
 
JAVA
 
“Homem de preto, qual é a sua missão?”
“É aprender logo Java e tirar Certificação!”
“Homem de preto, o que é que você faz?”
“Escrevo um código fonte que apavora o Satanás!”
SALVADOR, 2011, p. 2.
 
CARACTERÍSTICAS da linguagem de programação Java:
✓ «O termo Java não é uma sigla. Ele foi adotado por se tratar da bebida favorita de 
muitos programadores, o café [(Java é uma gíria americana para café – o café 
javanês)].» (HOLMES; JOYCE, 2001, p. 2);
✓ Lançada pela Sun Microsystems (James Gosling e equipe) em 1995 e mantida pela 
Oracle Corporation desde 2008;
✓ Suporta a orientação a objetos, bem como outros paradigmas de programação;
✓ Portabilidade para várias plataformas de sistema operacional (filosofia “write once, 
run anywhere”), por meio da JVM – Java Virtual Machine;
✓ Possui suporte a diversos protocolos de rede, tais como TCP/IP, HTTP e FTP;
✓ Sintaxe similar às linguagens C, C++ e C#;
✓ Facilita a criação de sistemas distribuídos e multitarefas;
✓ Provê o recurso de desalocação automática de memória, por meio do Garbage 
Collector (Coletor de Lixo);
✓ Destina-se ao desenvolvimento de aplicativos para Desktop, sistemas Web, Applets 
(aplicações embutidas em páginas Web) e aplicativos para telefones celulares e PDAs.
 
PLATAFORMAS de desenvolvimento em Java:
✓ J2SE (Java Standard Edition): plataforma destinada ao desenvolvimento de 
aplicações Desktop;
✓ J2EE (Java Enterprise Edition): plataforma destinada ao desenvolvimento de 
aplicações Web e corporativas;
✓ J2ME (Java Micro Edition): plataforma destinada ao desenvolvimento de aplicações 
móveis ou embarcadas.
 
AMBIENTES de programação em Java:
✓ JRE – Java Runtime Environment: JVM – Java Virtual Machine e API – Application 
Programming Interface (suporte a file system, GUI – Graphical User Interface, protocolos 
de rede etc.). Pode ser instalado separadamente;
✓ JDK – Java Development Kit: JRE, compilador Java (javac), ferramentas de depuração, 
ferramenta de gerenciamento de documentação (javadoc), entre outros. Pode ser 
instalado separadamente;
✓ IDE – Integrated Development Environment: BlueJ (https://www.blueJ.org), Eclipse 
(https://www.eclipse.org), NetBeans (https://netbeans.org), IntelliJ (https://www.jetbrains.com/idea/), JBuilder 
(https://www.embarcadero.com/br/jbuilder), JCreator (www.jcreator.com). Dependem da prévia instalação do JDK.
 Fases típicas de programação em Java.
Fonte: DEITEL, Harvey; DEITEL, Paul, 2010, p. 9.
(pré-compilação)
 
*.jar
*.war
*.ear
Fases típicas de programação em Java.
Fonte: DEITEL, Harvey; DEITEL, Paul, 2010, p. 9.
 Fases típicas de programação em Java.
Fonte: DEITEL, Harvey; DEITEL, Paul, 2010, p. 9.
 Esquema de Funcionamento da JVM.
Fonte: ROMANATO, 2013.
edição
compilação
carregamento
e verificação
execução
 
Camada da JVM na plataforma de 
Sistema Operacional.
Fonte: MARTINS, 2019.
 
Tipos de dados e sua alocação na memória.
 
int age = 30;
Tipos de dados e sua alocação na memória.
 
int age = 30;
char caractere = 'A';
Tipos de dados e sua alocação na memória.
 
Tipos de dados primitivos em Java.
Fonte: DEITEL, Harvey; DEITEL, Paul, 
2010, p. 1070.
(2 Bytes)
(1 Byte)
(2 Bytes)
(4 Bytes)
(8 Bytes)
(4 Bytes)
(8 Bytes)
(1 bit de informação 
com tamanho não 
precisamente definido)
 
IDENTIFICADORES (nomes de variáveis, constantes, funções e classes):
✓ Devem ser SIGNIFICATIVOS, sempre INICIADOS por uma letra, “$” ou “_”. APÓS O 
PRIMEIRO CARACTERE, são permitidos números. Não há limite de tamanho. 
Exemplos: age (int), isEnabled (boolean), deposit (double), cardRed1 (String);
✓ Java é CASE-SENSITIVE. Exemplo: pessoa, Pessoa e PESSOA são diferentes;
✓ Palavras reservadas NÃO são permitidas, tais como: abstract, boolean, break, byte, 
case, catch, char, class, const, continue, default, do, double, else, entre outras.
 
// Comentário de uma linha.
/* 
 Comentário 
 de várias
 linhas. 
*/
// Variáveis.
int age;
boolean isEnabled;
String cardRed1;
// Constantes (acréscimo da palavra-chave FINAL).
final String DEFAULT_FILE_PATH = ".\\RESOURCES\\";// Operador de atribuição.
int calculo = 10;
// Operadores aritméticos.
int soma = 2 + 2;
int subtr = 2 - 2;
int mult = 2 * 2;
int div = 2 / 2;
int resto = 2 % 2;
soma++; // incrementa em 1.
soma--; // decrementa em 1.
// Operadores de atribuição aritmética. 
calculo += 2; // --> calculo = calculo + 2;
calculo -= 2; // --> calculo = calculo - 2;
calculo *= 2; // --> calculo = calculo * 2;
calculo /= 2; // --> calculo = calculo / 2;
calculo %= 2; // --> calculo = calculo % 2;
 
// Operador de negação.
!isPositive; // NÃO isPositive.
// Operadores relacionais.
(soma > calculo) // maior que.
(soma < calculo) // menor que.
(soma >= calculo) // maior ou igual que.
(soma <= calculo) // menor ou igual que.
(soma == calculo) // igual a.
(soma != calculo) // diferente de.
// Operadores lógicos.
((a > b) && (c != d)) // "&&" um e outro.
((a > b) || (c != d)) // "||" um ou outro.
// Operador ternário.
String s = (soma > calculo) ? "é maior" : "é menor";
teste lógico retorno se
verdadeiro
retorno se
falso
 
// If: comando de controle condicional.
int a, b;
String s;
a = 10;
b = 20;
if(a > b) {
s = "A é maior que B";
} else if(a < b) {
s = "A é menor que B";
} else {
s = "A é igual a B";
}
 
// Classe System: saída de dados via console.
// Encontra-se no pacote <java.lang>, que é IMPORTADO IMPLÍCITA E AUTOMATICAMENTE.
System.out.print("Hello, World!"); // PRINT : saída de dados SEM quebra de linha.
System.out.println("Hello, World!"); // PRINTLN: saída de dados COM quebra de linha.
// Suporta concatenação de strings.
System.out.println("Hello, " + "World!");
// Suporta quebra de linha e tabulação DENTRO DA STRING.
System.out.println("Hello\nWorld");
System.out.println("Hello\tWorld");
 
public class Aula {
public static void main(String[] args) {
final int VALOR_ESPERADO = 10;
int parcela1, parcela2, soma;
String mensagem;
parcela1 = 3;
parcela2 = 2;
soma = parcela1 + parcela2;
if(VALOR_ESPERADO > soma) {
mensagem = "O valor esperado é maior que a soma.";
} else if(VALOR_ESPERADO < soma) {
mensagem = "O valor esperado é menor que a soma.";
} else {
mensagem = "O valor esperado é igual à soma.";
}
System.out.println(mensagem);
}
}
 
1. Leia um nome e imprima a mensagem: “Olá, nome informado!”
2. Imprima a tabuada de um número informado pelo usuário.
3. Crie um programa que:
a) imprima seu nome e, na linha de baixo, o nome da disciplina;
b) acrescente, na linha do nome, com espaço de 1 tabulação, o número de sua matrícula.
4. Crie um programa que:
a) inicialize duas variáveis inteiras na declaração e calcule e imprima o resto de sua 
divisão;
b) verifique se o resto calculado é 0 ou não, imprimindo uma mensagem adequada para 
ambos os casos.
5. Crie um programa que:
a) inicialize duas variáveis reais do tipo double e calcule e imprima, com mensagens 
adequadas, o resultado da soma, da subtração, da multiplicação e da divisão;
b) verifique se o resultado da soma é maior ou igual ao dobro da 2a parcela, imprimindo 
uma mensagem adequada para ambos os casos.
EXERCÍCIOS
 
6. Troque os valores das variáveis numero1 e numero2, e imprima o resultado de sua 
soma. A variável numero1 deve armazenar o valor 10 e a variável numero2 deve receber 
um valor informado pelo usuário.
7. Determine a quantidade de homens e mulheres, separadamente, que são maiores de 
idade, baseado em uma lista de 10 pessoas informada pelo usuário.
8. Desafio: imprima 50 números sorteados aleatoriamente de 1 a 100.
EXERCÍCIOS
 
// Classe Scanner: entrada de dados via console.
// import java.util.Scanner;
Scanner keyboard = new Scanner(System.in);
int age = keyboard.nextInt();
double deposit = keyboard.nextDouble();
float distance = keyboard.nextFloat();
long binaryNumber = keyboard.nextLong();
String name = keyboard.nextLine();
char character = keyboard.next().charAt(0);
 
// Classe Scanner: entrada de dados via console.
import java.util.Scanner;
public class Aula {
public static void main(String[] args) {
Scanner teclado = new Scanner(System.in);
int idade;
System.out.println("Qual é a sua idade? ");
idade = teclado.nextInt();
System.out.println("Idade = " + idade);
}
}
 
// Conversão de tipos de dados (type cast).
Scanner teclado = new Scanner(System.in);
System.out.println("Informe seu peso: ");
double peso = teclado.nextDouble();
int pesoInteiro = (int) peso;
double pesoDecimal = (double) pesoInteiro;
System.out.println("Seu peso é: " + pesoDecimal);
 
double peso = 57.5;
int pesoInteiro = (int) peso;
 
int pesoInteiro = (int) peso;
double pesoDecimal = (double) pesoInteiro;
 
// Switch: comando de controle de seleção múltipla.
Scanner teclado = new Scanner(System.in);
System.out.println("Digite uma letra: ");
char caractere = teclado.next().charAt(0);
switch(caractere) {
 case 'a':
 System.out.println("Informada a vogal A.");
 break;
 case 'e': case 'i': case 'o': case 'u':
 System.out.println("Informada uma vogal.");
 break;
 default:
 System.out.println("Informada uma consoante.");
 break;
}
 
// For: comando de controle de repetição (loop).
Scanner teclado = new Scanner(System.in);
System.out.println("Quantas vezes repetirá?");
final int QTD = teclado.nextInt();
for(int contador = 1; contador <= QTD; contador++) {
 System.out.println("Executa " + contador);
}
 
// While: comando de controle de repetição (loop).
Scanner teclado = new Scanner(System.in);
System.out.println("Quantas vezes repetirá?");
final int QTD = teclado.nextInt();
int contador = 1;
while(contador <= QTD) {
System.out.println("Executa " + contador);
contador++;
}
 
// Do-while: comando de controle de repetição (loop).
int valorAtual = 100;
do {
System.out.println("O valor atual é: " + valorAtual);
valorAtual += 50;
} while(valorAtual < 250);
 
// Break & continue: comandos de controle de fluxo.
final int QTD = 10;
for(int contador = 1; contador <= QTD; contador++) {
if(contador == 3)
continue;
if(contador == 5)
break;
System.out.println("Executa: " + contador);
}
/*
Saída no console:
> Executa: 1
> Executa: 2
> Executa: 4
*/
 
// Break & continue em loops aninhados.
final int QTD = 5;
int contador = 1;
while(contador <= QTD) {
for(int i = 1; i <= QTD; i++) {
if(i == 3)
break;
System.out.println("[FOR] Executa: " + i);
} 
System.out.println("[WHILE] Executa: " + contador);
contador++;
}
 
GUI – Graphical User Interface via kit de ferramentas gráfico SWING
Vide: <Estácio Programação I GUI via Swing.txt>
 
1. Faça um programa em Java para ler dois valores inteiros e imprimir o resultado da 
soma, subtração, multiplicação, divisão e resto da divisão.
2. Faça um programa em Java para ler dois valores reais e imprimir o resultado da soma, 
subtração, multiplicação e divisão.
3. Faça um programa em Java para ler o raio de um círculo. Em seguida, imprima o 
diâmetro e a área do círculo que possui esse raio. Utilize: A = PI x r2 e PI = 3,14.
4. Faça um programa em Java para calcular e imprimir o resultado das expressões 
abaixo:
a) 5 * 4 / 6 + 7
b) 5 * 4 / (6 + 7)
c) 5 * 4.0 / 6 + 7
d) 5 * 4 % 6 + 7
e) 5 * 4 / (float)6 + 7
f) (4 / 3) + (3.0 * 5)
g) (4 / 3.0) + (3 * 5)
h) (int)(4 / 3.0) + (3 * 5)
EXERCÍCIOS
 
5. Faça um programa em Java para ler um número inteiro e verificar se é ou não múltiplo 
de 5, imprimindo uma mensagem para cada caso.
6. Faça um programa em Java para ler um caractere OP, representando uma operação 
aritmética (+, -, *, /), e ler dois números reais A e B. Imprimir a expressão matemática 
junto com o seu resultado, no formato: a op b = resultado.
7. Faça um programa em Java para ler um número de alunos N. Em seguida, ler as notas 
dos N alunos e imprimir a média da turma. Faça uma solução com FOR e outra solução 
com WHILE.
8. Faça um programa em Java para ler as notas de alunos até que o usuário digite -1. Ao 
final, imprimir a quantidade de alunos, a média da turma, a maior nota e a menor nota.
EXERCÍCIOSORIENTAÇÃO
A OBJETOS
 
O paradigma orientado a objetos é um estilo de programar
baseado em OBJETOS QUE INTERAGEM ENTRE SI,
representando entidades do mundo real.
ENTIDADES
DO MUNDO
REAL
 
ENTIDADES
DO MUNDO
REAL
OBJETOS
O paradigma orientado a objetos é um estilo de programar
baseado em OBJETOS QUE INTERAGEM ENTRE SI,
representando entidades do mundo real.
 
Programas de computador podem ser muito complexos [...]. Um modo de se 
gerenciar e controlar essa complexidade é com abstração. Uma 
abstração de algo é uma visão simplificada dele. A 
abstração “OCULTA” os detalhes desnecessários e nos possibilita 
focar só nas partes que nos interessam. Por exemplo, um gráfico no 
jornal poderia ser uma abstração de como o mercado financeiro 
mundial está se comportando.
Nós usamos muitas abstrações em nosso dia a dia. Considere um carro. A 
maioria de nós tem uma visão abstrata de como um carro funciona. 
Sabemos interagir com ele para fazê-lo se comportar como queremos: 
pomos gasolina, viramos a chave, pressionamos alguns pedais e assim 
por diante. Mas, não necessariamente entendemos o que está 
acontecendo dentro do carro para fazê-lo se mover e[, de fato,] não – e[, de fato,] não 
precisamos. Milhões de nós usam carros todos os dias sem entender os 
detalhes de como funcionam.
HOLMES; JOYCE, 2001, p. 88.
 
Um programa [de computador] pode ser projetado como um conjunto de 
abstrações interativas. Em Java, essas abstrações são captadas em 
CLASSES. O criador de uma classe obviamente tem que conhecer todos 
os detalhes dela, mas, uma vez criada, outros programadores podem 
usar esta classe sem [precisar] conhecer seus detalhes internos. Eles só 
têm que conhecer sua INTERFACE, tal como o motorista de um carro 
pode usá-lo sem [precisar] conhecer como o motor funciona [...].
HOLMES; JOYCE, 2001, p. 88.
 
Classe é o MOLDE
de uma entidade do mundo real.
CLASSE
Bermuda
 
CLASSE
Bermuda
Uma classe é um tipo de molde, ou 
modelo, que DITA o que os objetos 
podem ou não ser e fazer.
WU, 2010, p. 17.
 
Objeto é a MATERIALIZAÇÃO
de uma entidade do mundo real,
baseado em uma classe.
OBJETO
bermuda
 
OBJETO
bermuda
Em um programa [orientado a objetos], [...] todo 
objeto é uma INSTÂNCIA 
[(ocorrência)] de uma classe.
[Todos os objetos criados a partir de uma classe, 
compartilharão as características descritas 
por essa classe.]
GRUPO PET-TELE, 2009, p. 7.
 
CLASSE
em Java
class Bermuda {
 double cintura; // 34cm.
 double comprimento; // 37cm.
 double quadril; // 36cm.
 void imprimeMedidas() {
 System.out.println(
 “cint.:” + cintura + “, ”+
 “compr.:” + comprimento + “, ”+
 “quadril:”+ quadril
 );
 }
 
 // Outros métodos...
}
atributos
métodos
 
OBJETO
em Java Bermuda bermuda = new Bermuda();
tipo de dado
objeto
 
Atributo define uma CARACTERÍSTICA da classe.
class Bermuda {
 double cintura; // 34cm.
 double comprimento; // 37cm.
 double quadril; // 36cm.
 // Outros métodos...
}
atributos
 
class Bermuda {
 // ...
 void imprimeMedidas() {
 System.out.println(
 “cint.:” + cintura + “, ”+
 “compr.:” + comprimento + “, ”+
 “quadril:”+ quadril
 );
 }
 
 // Outros métodos...
}
métodos
Método define um COMPORTAMENTO da classe.
 
MENSAGEM!!!
 
New é o operador responsável por
INSTANCIAR o objeto na memória.
Bermuda bermuda = new Bermuda();
instanciação
construtor
Criamos um objeto invocando o operador new [...]:
nomeDoObjeto = new ConstrutorDaClasse(argumentos);
WU, 2010, p. 35.
 
Bermuda bermuda = new Bermuda();
construtor
Um construtor é um método 
especial executado quando uma nova 
instância da classe é criada, ou seja, 
quando o operador new é chamado.
WU, 2010, p. 158.
class Bermuda {
 // Atributos...
 // Construtor sem argumentos.
 Bermuda() {
 cintura = 0.0;
 comprimento = 0.0;
 quadril = 0.0;
 }
 
 // Métodos...
}
construtor
 
Bermuda bermuda = new Bermuda();
construtor
Se nenhum construtor for definido para 
uma classe, então o compilador do Java 
INCLUIRÁ automaticamente um 
CONSTRUTOR PADRÃO.
Um construtor padrão é um 
construtor que NÃO aceita argumentos e 
NÃO tem declarações em seu corpo [(está 
vazio)].
WU, 2010, p. 176.
class Bermuda {
 // Atributos...
 // Construtor padrão, incluído
 // automaticamente pelo
 // compilador do Java.
 
 // Métodos...
}
 
O modificador de nível de acesso
private
ENCAPSULA (oculta) 
o atributo ou método 
do exterior da classe.
O modificador de nível de acesso
public
EXPÕE
o atributo ou metodo
ao exterior da classe.
public class Bermuda {
 private double cintura;
 private double comprimento;
 private double quadril;
 
 public Bermuda() {
 cintura = 0.0;
 comprimento = 0.0;
 quadril = 0.0;
 }
 
 public void imprimeMedidas() {
 System.out.println(...);
 }
}
 
[...] Quando ocultamos dados em uma classe, dizemos que estes dados 
foram ENCAPSULADOS.
[...] Mas, por que desejaríamos ocultar os detalhes de implementação de 
uma classe? [...] [Uma] razão para o encapsulamento é preservar a 
integridade dos dados da sua classe. O acesso direto aos dados da 
classe pode fazer com que as variáveis não sejam corretamente 
atualizadas.
HOLMES; JOYCE, 2001, p. 88.
 
O método de acesso
Get
permite
LER
o valor do atributo.
O método de acesso
Set
permite
ESCREVER
um valor no atributo.
public class Bermuda {
 // Atributos.
 private double cintura;
 private double comprimento;
 private double quadril;
 
 // Construtor.
 public Bermuda() { /* ... */ }
 
 // Métodos.
 public double getCintura() {
 return cintura;
 }
 
 public void setCintura(double novaMedida){
 cintura = novaMedida;
 }
 // Outros getters e setters.
}
 
1. Implemente a classe pública Empresa, contendo:
a) os atributos privados: cnpj (String), nome (String), endereco (String);
b) um construtor público, com os argumentos: doc (String), nm (String), end (String), 
responsáveis por inicializar os atributos da classe correspondentes;
c) o método de acesso Get, público, para cada atributo da classe.
2. Implemente a classe pública Retangulo, contendo:
a) os atributos privados: largura (double), altura (double);
b) um construtor público vazio, responsável por inicializar os atributos da classe com 
valores padrão;
c) os métodos de acesso Get e Set, públicos, para cada atributo da classe;
d) o método public double getArea(), responsável por calcular e retornar a medida da 
área deste retângulo (área do retângulo = largura x altura).
3. Implemente a classe pública Produto, contendo:
a) os atributos privados: codigoDeBarras (String), descricao (String), unidade 
(String), valorUnitario (double);
b) um construtor público, com os argumentos: cod (String), nm (String), unid (String), 
vlr (double), responsáveis por inicializar os atributos da classe correspondentes;
c) o método de acesso Get, público, para cada atributo da classe.
EXERCÍCIOS
 
4. Implemente a classe pública ContaBancaria, contendo:
a) os atributos privados: numero (String), nomeDoTitular (String), tipo (String), saldo 
(double);
b) um construtor público, com os argumentos: num (String), tit (String), tp (String), 
sld (double), responsáveis por inicializar os atributos da classe correspondentes;
c) o método de acesso Get, público, para cada atributo da classe;
d) os métodos public void saca(double valor) e 
public void deposita(double valor), responsáveis, respectivamente, por debitar e 
creditar o atributo saldo, conforme o argumento valor.
5. Implemente a classe pública Usuario, contendo:
a) os atributos privados: matricula (String), nome (String), senha (String), isGerente 
(boolean);
b) um construtor público, com os argumentos: mat (String), nm (String), snh (String), 
ehGerente (boolean), responsáveis por inicializar os atributos da classe 
correspondentes;
c) o método de acesso Get, público, para os atributos: matricula, nome, senha.d) o método public boolean isGerente(), para ler o valor do atributo isGerente.
EXERCÍCIOS
 
6. Implemente a classe pública Bicicleta, contendo:
a) os atributos privados: marca (String), velocidade (double), marcha (int);
b) um construtor público, com o argumento m (String), responsável por inicializar o 
atributo marca. Os atributos velocidade e marcha devem ser inicializados com os 
valores padrão 0 e 1, respectivamente;
c) o método de acesso Get, público, para cada atributo da classe;
d) o método public void mudaMarcha(boolean isAumenta), responsável por aumentar 
ou diminuir o valor do atributo marcha, de uma em uma unidade, entre a 1ª e a 4ª 
marcha. Utilize o argumento isAumenta para saber quando aumentar ou diminuir o valor 
do atributo marcha;
e) o método public void mudaVelocidade(double valor, boolean isAumenta), 
responsável por aumentar ou diminuir o valor do atributo velocidade, conforme o 
argumento valor. O menor valor do atributo velocidade deve ser 0. Utilize o 
argumento isAumenta para saber quando aumentar ou diminuir o valor do atributo 
velocidade;
f) o método public void aplicaFreio(double decremento), responsável por diminuir 
o valor do atributo velocidade, conforme o valor do argumento decremento. O menor 
valor do atributo velocidade deve ser 0.
EXERCÍCIOS
 
7. Implemente a classe pública Cupom, contendo:
a) os atributos privados: empresa (Empresa), cliente (Cliente), usuario (Usuario);
b) um construtor público, com os argumentos: empresa (Empresa), cliente (Cliente), 
usuario (Usuario), responsáveis por inicializar os atributos da classe correspondentes;
c) o método de acesso Get, público, para cada atributo da classe.
8. Implemente a classe pública ItemDoCupom, contendo:
a) os atributos privados: sequencial (int), produto (Produto), quantidade (double), 
desconto (double);
b) um construtor público, com os argumentos: sequencial (int), produto (Produto), 
quantidade (double), desconto (double), responsáveis por inicializar os atributos da 
classe correspondentes;
c) o método de acesso Get, público, para cada atributo da classe;
d) o método de acesso public void setDesconto(double percentual), para escrever o 
valor do percentual de desconto no atributo desconto.
EXERCÍCIOS
 
THIS!!!
 
Sobrecarga (overloading) é o mecanismo que possibilita que
dois ou mais métodos/construtores
tenham o MESMO NOME,
desde que seus ARGUMENTOS
sejam OBRIGATORIAMENTE diferentes
em TIPO e/ou QUANTIDADE
(ORACLE, 2018a; SILVEIRA; AMARAL, 2014, p. 214).
// Adaptado de ORACLE, 2018a.
public class Artist {
 public void draw(String s) { /* ... */ }
 public void draw(int i) { /* ... */ }
 public void draw(double f) { /* ... */ }
 public void draw(int i, double f) { /* ... */ }
}
 
Você NÃO pode declarar mais de um método com o mesmo nome e 
a mesma quantidade e tipo de argumentos, porque o compilador 
não consegue diferenciá-los.
ORACLE, 2018a.
O compilador NÃO considera o tipo de retorno ao diferenciar métodos. 
Então, você NÃO pode declarar dois métodos com a MESMA ASSINATURA 
[(nome + tipo e quantidade de argumentos)], mesmo que tenham um tipo de 
retorno diferente.
ORACLE, 2018a.
 
CLASSE MATH!!!
 
ATRIBUTOS E MÉTODOS 
ESTÁTICOS!!!
 
OBJETOS COMO ARGUMENTOS
&
CONSTRUTOR DE CÓPIA!!!
 
ARRANJOS
DE TIPOS PRIMITIVOS
&
DE OBJETOS!!!
 
CLASSE STRING!!!
 
HERANÇA
 
Herança é o mecanismo que possibilita aproveitar
CARACTERÍSTICAS (atributos) e
COMPORTAMENTOS (métodos)
de uma classe na composição de novas classes.
SUPER
CLASSE
SUB
CLASSE
 
Se uma classe B é derivada por herança de uma classe A, podemos dizer 
que “B é um tipo de A”. Isso porque B tem todas as características de A 
e, além disso, suas próprias. É como dizer que um estorninho [(foto 
abaixo)] é um tipo de pássaro: um estorninho tem as características 
compartilhadas por todos os pássaros (asas, penas e assim por diante), 
mas tem algumas características distintas próprias (tal como uma 
plumagem matizada escura). Por esta razão, a herança é frequentemente 
chamada de um relacionamento “tipo de”.
LAFORE, 2002, p. 415.
 
… tipo de
funcionário
… tipo de
veículo
… tipo de
polígono
 
HERANÇA
SIMPLES
HERANÇA
MÚLTIPLA
A linguagem Java NÃO possui 
suporte a herança múltipla!
 
public class Inimigo {
private int vidaQtd;
protected String nome;
public Inimigo(int vidaQtd) {
this.vidaQtd = vidaQtd;
}
public int getVidaQtd() {
return vidaQtd;
}
public void incrementaVida(int qtd) {
vidaQtd += qtd;
}
public void decrementaVida(int qtd) {
vidaQtd -= qtd;
}
}
 
public class Polvo extends Inimigo {
public int tentaculosQtd;
public Polvo(int tentaculosQtd, int vidaQtd) {
super(vidaQtd);
this.tentaculosQtd = tentaculosQtd;
}
public void agarra() {
System.out.println("Polvo te agarrou!");
}
}
public class Zumbi extends Inimigo {
public Zumbi(String nome, int vidaQtd) {
super(vidaQtd);
this.nome = nome;
}
public void morde() {
System.out.println("Zumbi " + nome + " te mordeu!");
}
}
 
Um membro de classe [(atributo ou método) com o modificador de 
nível de acesso] protected PODE SER ACESSADO a partir de 
CLASSES que estejam NO MESMO PACOTE e a partir de SUBCLASSES 
que estejam EM OUTROS PACOTES.
Ele NÃO ESTARÁ ACESSÍVEL[, porém,] a partir de CLASSES NÃO 
CORRELACIONADAS que estejam EM OUTROS PACOTES.
WU, 2010, p. 746.
 
public class Inimigo {
//...
public void emiteSom() {
System.out.println("Buuu!");
}
}
public class Polvo extends Inimigo {
//...
public void emiteSom() {
System.out.println("Woarrr!");
}
}
public class Zumbi extends Inimigo {
//...
public void emiteSom() {
System.out.println("Grrr!");
}
} POLIMORFISMO
 
1. Modifique a classe pública ContaBancaria, implementada anteriormente, para se 
tornar a superclasse das subclasses: ContaCorrente e ContaPoupanca.
2. Implemente a classe pública, ItemDoCupomEmAbastecimento, que herda da classe 
ItemDoCupom, contendo:
a) o atributo privado: bico (String);
b) um construtor público, com os argumentos: bico (String), produto (Produto), 
quantidade (double), responsáveis por inicializar os atributos correspondentes desta 
classe e da superclasse;
c) o método de acesso Get, público, para o atributo bico.
EXERCÍCIOS
 
CLASSE ABSTRATA
 
Classe abstrata é uma variação 
do mecanismo de herança, na qual a
SUPERCLASSE
NÃO pode ser instanciada.
SUPER
CLASSE
(ABSTRATA)
SUB
CLASSE
(CONCRETA)
 
public abstract class Inimigo {
private int vidaQtd;
protected String nome;
public Inimigo(int vidaQtd) { /* ... */ }
public int getVidaQtd() { /* ... */ }
public void incrementaVida(int qtd) { /* ... */ }
public void decrementaVida(int qtd) { /* ... */ }
}
public class Polvo extends Inimigo {
public int tentaculosQtd;
public Polvo(int tentaculosQtd, int vidaQtd) { /* ... */ }
public void agarra() { /* ... */ }
}
public class Zumbi extends Inimigo {
public Zumbi(String nome , int vidaQtd) { /* ... */ }
public void morde() { /* ... */ }
}
 
public abstract class Inimigo {
// ...
public abstract void emiteSom();
}
public class Polvo extends Inimigo {
//...
public void emiteSom() {
System.out.println("Woarrr!");
}
}
public class Zumbi extends Inimigo {
//...
public void emiteSom() {
System.out.println("Grrr!");
}
}
MÉTODO
ABSTRATO
 
public static void main(String[] args) {
 Polvo polvo = new Polvo(8, 5);
 Imimigo zumbiCharlie = new Zumbi("Charlie", 5);
 if(polvo instanceof Inimigo)
 System.out.println("O objeto POLVO é uma " +
 "instância da superclasse abstrata INIMIGO.");
}
 
INTERFACE
 
Interface é o mecanismo que possibilita definir um “contrato”, 
com os COMPORTAMENTOS (métodos)
que TODAS as classes sujeitas DEVEM possuir.
INTERFACE
CLASSE
IMPLEMENTADORA
(REALIZADORA)
 
INTERFACE, 2018a.
INTERFACE, 2018b.
 
public interface Controles {
public void ligaDesliga();
public void sintoniza(double novo);
public void aumentaVolume(int qtd);
public void diminuiVolume(int qtd);
}
public abstractclass Tv implements Controles {
private boolean isLigada;
private int canal;
private int volume;
public void ligaDesliga() {
isLigada = !isLigada;
}
public void sintoniza(double novo) {
canal = novo;
}
public void aumentaVolume(int qtd) {
volume += qtd;
}
public void diminuiVolume(int qtd) {
volume -= qtd;
}
}
 
public class TvSmartFH001 extends Tv {
public final String MODELO = "Smart TV Full HD 001";
public boolean isConectada = false;
private void conectaAInternet(String url) { /* ... */ }
public void navega(String url) {
if(!isConectada)
conectaAInternet();
// Acessa a URL informada.
}
}
 
public abstract class Radio implements Controles {
private boolean isLigado;
private int estacao;
private int volume;
private FonteDeAudio fonteDeAudio;
public void plugaFonteDeAudio(FonteDeAudio fonte) {
fonteDeAudio = fonte;
}
public void ligaDesliga() {
isLigado = !isLigado;
}
public void sintoniza(double novo) {
estacao = novo;
}
public void aumentaVolume(int qtd) {
volume += qtd;
}
public void diminuiVolume(int qtd) {
volume -= qtd;
}
}
 
1. Implemente a classe abstrata Cliente, contendo:
a) os atributos: nome (String), endereco (String), telefone (String);
b) um construtor, com os argumentos: nome (String), endereco (String), telefone 
(String), responsáveis por inicializar os atributos da classe correspondentes;
c) o método de acesso Get de cada atributo da classe.
2. Implemente a classe PessoaFisica, que herda da classe Cliente e contém:
a) o atributo: cpf (String);
b) um construtor, com os argumentos: cpf (String), nome (String), endereco (String), 
telefone (String), responsáveis por inicializar os atributos correspondentes desta 
classe e da superclasse;
c) o método de acesso Get do atributo cpf.
3. Implemente a classe PessoaJuridica, que herda da classe Cliente e contém:
a) os atributos: cnpj (String), contato (String);
b) um construtor, com os argumentos cnpj (String), nome (String), endereco (String), 
telefone (String), contato (String), responsáveis por inicializar os atributos 
correspondentes desta classe e da superclasse;
c) o método de acesso Get dos atributos: cpf, contato.
EXERCÍCIOS
 
4. Implemente a interface ImpressoraFiscal, contendo:
a) o método public void imprime(Cupom cupom).
5. Implemente as classes IFBematech, IFDaruma e IFSweda, que realizam a interface 
ImpressoraFiscal, e o método public void imprime(Cupom cupom) em cada uma delas.
EXERCÍCIOS
 
6. Implemente a classe abstrata ContaBancaria, contendo:
a) os atributos: numero (String), nomeDoTitular (String), tipo (String), saldo (double);
b) um construtor, com os argumentos: numero (String), nomeDoTitular (String), tipo 
(String), saldo (double), responsáveis por inicializar os atributos correspondentes;
c) o método de acesso Get de cada atributo da classe;
d) os métodos abstrados: public void saca(double valor) e
public void deposita(double valor).
7. Implemente a classe ContaCorrente, que herda da classe ContaBancaria, contendo:
a) o atributo: taxaDeOperacao (double);
b) um construtor, com o argumento extra: taxaDeOperação (double), responsável por 
inicializar o atributo correspondente;
c) os métodos concretros: public void saca(double valor) e
public void deposita(double valor), responsáveis, respectivamente, por debitar e 
creditar o atributo saldo, conforme o argumento valor. O atributo taxaDeOperacao 
deve ser descontado sempre que um saque e um depósito forem feitos.
EXERCÍCIOS
 
8. Implemente a classe ContaPoupanca, que herda da classe ContaBancaria, contendo:
a) o atributo: limite (double);
b) um construtor, com o argumento extra: limite (double), responsável por inicializar o 
atributo correspondente;
c) os métodos concretros: public void saca(double valor) e
public void deposita(double valor), responsáveis, respectivamente, por debitar e 
creditar o atributo saldo, conforme o argumento valor. O atributo limite deve conceder 
um crédito ao titular, se precisar sacar valor maior que o saldo. Neste caso, o saldo pode 
ficar negativo, desde que não ultrapasse o limite.
9. Implemente a interface Imprimivel, contendo o método mostrarDados().
10. Faça com que as classes ContaCorrente e ContaPoupanca realizem a interface 
Imprimivel e, na implementação do método, imprima os atributos de cada conta.
11. Implemente a classe Relatorio, contendo um método gerarRelatório(), que 
receba um objeto Imprimivel e execute o método mostrarDados() deste objeto.
EXERCÍCIOS
 
12. Implemente uma classe contendo o método main e:
a) instancie uma conta de cada tipo;
b) efetue depósitos e saques em cada uma. Observação: em ContaPoupanca, efetue um 
saque maior que o saldo atual;
c) instancie um objeto Relatorio e execute o método gerarRelatorio() para cada 
conta instanciada.
13. Incremente a classe ContaBancaria com o método transferir(), que:
a) receba o argumento o valor (double) e um objeto ContaBancaria;
b) transfira o valor desejado da conta atual para cada conta informada. Use os métodos 
sacar e depositar para isso.
EXERCÍCIOS
 
TRATAMENTO
DE EXCEÇÕES
 
Exceção é um evento que ocorre durante a execução de um programa e 
que torna a sua continuidade impossível ou indesejável.
HOLMES; JOYCE, 2001, p. 376.
EXCEÇÃO
 
Exemplos de exceções incluem divisão por zero [(division by zero)], 
estouro aritmético [(arithmetic overflow)], índice fora dos limites de 
um arranjo [(index out of bounds)], ou uma condição de falha em um 
periférico.
Muitas linguagens de programação respondem a uma exceção abortando 
a execução [do programa]. [...] [A linguagem Java, porém, utiliza] um 
manipulador de exceções[,] [...] um trecho de código do 
programa que é automaticamente invocado quando uma exceção ocorre. 
O manipulador de exceção pode tomar uma ação corretiva apropriada, 
permitindo a retomada da execução do programa (no ponto em que a 
exceção ocorreu, ou em outro), ou o encerramento do programa de modo 
controlado.
HOLMES; JOYCE, 2001, p. 376.
 
O propósito do tratamento de exceções é permitir ao programador 
corrigir exceções que ocorram nas seguintes circunstâncias:
● Exceções causadas por usuários. Um usuário pode digitar errado ou 
fornecer dados inapropriados ao seu sistema. Para prevenir falhas 
no seu programa, você precisa desenvolver uma mentalidade de 
programação defensiva, que conte com o tratamento de exceções.
● Exceções que indiquem erros no programa e sirvam como mecanismo 
de depuração.
● Erros de fora do programa, por exemplo, uma condição de falha em 
um periférico. Um sistema de computador tolerante a falhas é capaz 
de funcionar completa ou parcialmente depois de um defeito ter 
ocorrido. Softwares tolerantes a falhas podem conter tratamentos 
de exceções. Um sistema de computador que forneça um nível 
reduzido de serviço diante da ocorrência de pelo menos uma falha 
está em um estado de degradação graciosa. Técnicas para tratar 
falhas são de vital importância no projeto e implementação de 
sistemas de computador críticos à segurança, nos quais a vida das 
pessoas pode ser posta em risco por malfuncionamento.
● Recuperação de eventos incomuns, mas não inesperados.
HOLMES; JOYCE, 2001, p. 376.
 
public int quociente(int numerador, int denominador) {
return numerador / denominador;
}
DEITEL, Harvey; DEITEL, Paul, 2010, p. 337-338.
 
public static int quociente(int numerador, int denominador) 
 throws java.lang.ArithmeticException {
 return numerador / denominador;
}
public static void main(String[] args) {
 java.util.Scanner scanner = new java.util.Scanner(System.in);
 boolean continueLoop = true;
 do {
 try {
 System.out.println("Numerador: ");
 int numerador = scanner.nextInt();
 System.out.println("Denominador: ");
 int denominador = scanner.nextInt();
 System.out.println("Quociente: " + quociente(numerador, denominador));
 continueLoop = false;
 } catch(java.util.InputMismatchException inputMismatchException) {
 System.err.println("Exception: " + inputMismatchException);scanner.nextLine(); // descarta o input, p/ digitar novamente.
 System.out.println("Somente inteiros. Tente novamente.");
 } catch(java.lang.ArithmeticException arithmeticException) {
 System.err.println("Exception: " + arithmeticException);
 System.out.println("Zero é um denominador inválido. Tente novamente.");
 }
 } while(continueLoop);
}
 
DEITEL, Harvey; DEITEL, Paul, 2010, p. 339-340.
 
// Exemplo de uso do tipo de exceção IndexOutOfBoundsException.
Scanner scanner = new Scanner(System.in);
int numero = 0;
int indice = 0;
int[] arrayDeInteiros = new int[10];
try { 
System.out.println("Informe um número: ");
numero = scanner.nextInt();
System.out.print("Informe o índice do array: ");
indice = scanner.nextInt();
arrayDeInteiros[indice] = numero;
} catch(java.lang.IndexOutOfBoundsException indexOutOfBoundsException) { 
System.out.println("Problema: " + indexOutOfBoundsException.getMessage());
System.out.println("Onde aconteceu" + indexOutOfBoundsException.printStackTrace();
}
 
// Exemplo de uso do bloco TRY-CATCH-FINALLY.
// GOMES, 2012.
String frase = null;
String novaFrase = null;
try {
 novaFrase = frase.toUpperCase();
} catch(java.lang.NullPointerException e) {
 System.out.println("A frase inicial está nula. " +
 "Para solucionar o problema, foi atribuito um valor padrão.");
 frase = "Frase vazia";
} finally {
 novaFrase = frase.toUpperCase();
}
System.out.println("Frase antiga: "+ frase);
System.out.println("Frase nova: " + novaFrase);
 
// Exemplo de uso da palavra reservada THROW.
public void saca(double valor) {
if (this.saldo < valor) {
throw new RuntimeException();
} else {
this.saldo -= valor;
}
}
 
Durante a execução de uma aplicação, erros podem acontecer. A 
linguagem Java oferece um mecanismo para que o programador possa 
definir as providências apropriadas a serem tomadas na hora em que 
um erro de execução ocorrer.
Os erros de execução são classificados em algumas categorias. É 
fundamental que você seja capaz de, dado um erro de execução, 
determinar seu tipo. A classificação das categorias depende 
exclusivamente da hierarquia das classes que modelam os erros de 
execução.
A classe principal dessa hierarquia é a Throwable. Qualquer erro 
de execução é um objeto dessa classe ou de uma que deriva dela.
SILVEIRA; AMARAL, 2014, p. 331-332.
 
Como filhas diretas de Throwable temos: Error e Exception.
Os Errors são erros de execução gerados por uma situação totalmente 
anormal que não deveria ser prevista pela aplicação. Por exemplo, um 
OutOfMemoryError é gerado quando a JVM não tem mais memória RAM 
disponível para oferecer para as aplicações. Em geral, esse tipo de 
erro não é responsabilidade das aplicações pois quem cuida do 
gerenciamento de memória é a JVM.
Por outro lado, as Exceptions são erros de execução que são de 
responsabilidade das aplicações, ou seja, são as aplicações que devem 
tratar ou evitar esses erros. Por exemplo, um SQLException é gerado 
quando algum erro ocorre na comunicação entre a aplicação e o banco 
de dados. Esse tipo de erro deve ser tratado ou evitado pela aplicação.
SILVEIRA; AMARAL, 2014, p. 331-332.
 
Por sua vez, as Exceptions são divididas em duas categorias: as UNCHECKEDs e as 
CHECKEDs.
As uncheckeds são exceptions que teoricamente podem ser mais facilmente evitadas 
pelo próprio programador se ele codificar de maneira mais cuidadosa. As checkeds 
são exceptions que teoricamente não são fáceis de evitar, de modo que a melhor 
abordagem é estar sempre preparado para seu acontecimento.
As uncheckeds são definidas pelas classes que derivam de RuntimeException, que 
por sua vez é filha direta de Exception. As outras classes na árvore da Exception 
definem as checkeds.
SILVEIRA; AMARAL, 2014, p. 331-332.
 
1. O código abaixo lança uma exceção (propositalmente) e interrompe sua execução. 
Utilizando o tratamento de exceções, corrija a classe com o objetivo de não parar sua 
execução. Obs: A Exception lançada é ArrayIndexOutOfBoundsException.
public class TesteException {
public static void main(String[] args) {
System.out.println("inicio do main");
metodo1();
System.out.println("fim do main");
}
static void metodo1() {
System.out.println("inicio do metodo1");
metodo2();
System.out.println("fim do metodo1");
}
static void metodo2() {
System.out.println("inicio do metodo2");
int[] array = new int[10];
for(int i = 0; i <= 15; i++) {
array[i] = i;
System.out.println(i);
}
System.out.println("fim do metodo2");
}
}
EXERCÍCIOS
 
2. Reescreva as partes problemáticas do código abaixo com tratamento de exceções. Ou 
seja, identifique todas as exceções que podem ser levantadas e, para cada uma, dê o 
tratamento adequado, que, nesse exercício, significa alertar o usuário sobre o problema. 
Entretanto, nesse programa, a leitura dos valores deve ser feita, mesmo que para isso o 
usuário tenha que tentar informá-los várias vezes na mesma execução do programa.
public class Questao2 {
public static void main(String[] args) {
Scanner teclado = new Scanner(System.in);
System.out.println("Eu sei dividir!");
System.out.print("Informe o 1o valor: ");
int x = teclado.nextInt();
System.out.print("Informe o 2o valor: ");
int y = teclado.nextInt();
double r = (x/y);
System.out.println("O resultado da soma e: " + r);
}
}
EXERCÍCIOS
 
COLEÇÕES
 
CANTÙ, Marco. Essential Pascal. 2nd ed. [S.l.]: Marco Cantù Books, 2003.
COUGHLAN, Michael. Beginning COBOL for Programmers. New York: Apress, 2014.
DEITEL, Harvey M.; DEITEL, Paul J. Java: Como Programar. Tradução Edson 
Furmankiewicz. 8. ed. São Paulo: Pearson Prentice Hall, 2010.
FREEMAN, Adam. Introducing Visual C# 2010. New York: Apress, 2010.
GOMES, Robson F. Tratando Exceções em Java. Devmedia. 2012. Disponível em: 
<https://www.devmedia.com.br/tratando-excecoes-em-java/25514>. Acesso em: 13 
nov. 2018.
GRUPO PET-TELE. Tutorial de Programação Orientada a Objeto. Escola de Engenharia, 
Universidade Federal Fluminense. Niterói: [s.n.], 2009. Disponível em: 
<http://www.telecom.uff.br/pet/petws/downloads/tutoriais/oop/tut_oop_2k100127.pd
f>. Acesso em: 27 ago. 2018.
HOLMES, Barry J.; JOYCE, Daniel T. Object-Oriented Programming with Java. 2nd ed. 
Sudbury: Jones and Bartlett Publishers, 2001.
REFERÊNCIAS
 
INTERFACE. Dicionário Priberam da Língua Portuguesa online, 2008-2013. Disponível 
em: <https://dicionario.priberam.org/interface>. Acesso em: 05 nov. 2018a.
INTERFACE. Dicionário Michaelis de Português online, 1998-2009. Melhoramentos. 
Disponível em: <https://michaelis.uol.com.br/moderno-portugues/busca/portugues-
brasileiro/interface/>. Acesso em: 05 nov. 2018b.
MARTINS, Eder. Java Virtual Machine (JVM) - Parte I. JVM Total. Disponível em: 
<https://sites.google.com/site/jvmtotal/home/conceitos/java-virtual-machine>. Acesso 
em: 08 jan. 2019.
ORACLE. The Java™ Tutorials: Defining Methods. Disponível em: 
<https://docs.oracle.com/javase/tutorial/java/javaOO/methods.html>. Acesso em: 02 
set. 2018a.
POO, Danny; KIONG, Derek; ASHOK, Swarnalatha. Object-Oriented Programming 
and Java. 2nd ed. London: Springer, 2008.
REFERÊNCIAS
 
ROMANATO, Allan. Introdução ao Java Virtual Machine (JVM). Devmedia. 2013. 
Disponível em: <https://www.devmedia.com.br/introducao-ao-java-virtual-machine-
jvm/27624>. Acesso em: 08 jan. 2019.
SALVADOR, Fábio B. Loucademia de Java – Versão 1.0. [S.l.]: [s.n.]. Disponível em: 
<www.fabiosalvador.com.br>. Acesso em: 07 jan. 2011.
SHELLY, Gary B. et al. Java Programming: Comprehensive Concepts and Techniques. 
3rd ed. Boston: Cengage Learning, 2006.
SILVEIRA, Guilherme; AMARAL, Mário. Java SE 7 Programmer I: O Guia para sua 
Certificação Oracle Certified Associate. São Paulo: Casa do Código, 2014.
TOAL, Ray. Programming Paradigms. Notes. Loyola Marymount University, College of 
Science and Engineering, Computer Science Division. Disponível em: 
<http://cs.lmu.edu/~ray/notes/paradigms/>. Acesso em: 06 ago. 2018.
WU, C. Thomas. An Introduction to Object-OrientedProgramming with Java. 5th ed. 
New York: McGraw-Hill, 2010.
REFERÊNCIAS
	Slide 1
	Slide 2
	Slide 3
	Slide 4
	Slide 5
	Slide 6
	Slide 7
	Slide 8
	Slide 9
	Slide 10
	Slide 11
	Slide 12
	Slide 13
	Slide 14
	Slide 15
	Slide 16
	Slide 17
	Slide 18
	Slide 19
	Slide 20
	Slide 21
	Slide 22
	Slide 23
	Slide 24
	Slide 25
	Slide 26
	Slide 27
	Slide 28
	Slide 29
	Slide 30
	Slide 31
	Slide 32
	Slide 33
	Slide 34
	Slide 35
	Slide 36
	Slide 37
	Slide 38
	Slide 39
	Slide 40
	Slide 41
	Slide 42
	Slide 43
	Slide 44
	Slide 45
	Slide 46
	Slide 47
	Slide 48
	Slide 49
	Slide 50
	Slide 51
	Slide 52
	Slide 53
	Slide 54
	Slide 55
	Slide 56
	Slide 57
	Slide 58
	Slide 59
	Slide 60
	Slide 61
	Slide 62
	Slide 63
	Slide 64
	Slide 65
	Slide 66
	Slide 67
	Slide 68
	Slide 69
	Slide 70
	Slide 71
	Slide 72
	Slide 73
	Slide 74
	Slide 75
	Slide 76
	Slide 77
	Slide 78
	Slide 79
	Slide 80
	Slide 81
	Slide 82
	Slide 83
	Slide 84
	Slide 85
	Slide 86
	Slide 87
	Slide 88
	Slide 89
	Slide 90
	Slide 91
	Slide 92
	Slide 93
	Slide 94
	Slide 95
	Slide 96
	Slide 97
	Slide 98
	Slide 99
	Slide 100
	Slide 101
	Slide 102
	Slide 103
	Slide 104
	Slide 105
	Slide 106
	Slide 107
	Slide 108
	Slide 109
	Slide 110
	Slide 111
	Slide 112
	Slide 113
	Slide 114
	Slide 115
	Slide 116
	Slide 117
	Slide 118
	Slide 119
	Slide 120
	Slide 121
	Slide 122
	Slide 123
	Slide 124
	Slide 125