Programação Orientada a Objetos

Prévia do material em texto

PARADIGMAS DE COMPUTAÇÃO
Programação
Orientada a Objetos SEMANA 1
entender a diferença entre os paradigmas de programação estruturada, não estruturada e o paradigma
de programação orientada a objetos;
tratar de alguns frameworks de desenvolvimento para facilitar a criação de aplicações segundo o
paradigma de orientação a objetos.
Programação orientada a objetos, também conhecida por sua sigla POO, facilita a relação da máquina com
o mundo real. Isso porque qualquer coisa que pertence ao mundo físico pode ter um representante na
esfera digital: uma pessoa, um emprego, um objeto, enfim, são infinitas as possibilidades. Essas “coisas” são
o que chamamos de objetos na POO. O enfoque da modelagem de sistema por objetos procura
enxergar o mundo como um conjunto de objetos que interagem entre si e apresentam
características e comportamentos próprios representados por seus atributos e suas operações.
Os atributos estão relacionados aos dados, e as operações, aos processos que um objeto executa.
Trata-se de uma forma de classificar as linguagens de programação baseada em suas
funcionalidades. Um paradigma fornece e determina a visão que o programador possui sobre a
estruturação e execução do programa.
Programadores abstraem o programa
como uma sequência de funções
executadas de modo empilhado. Trata da
computação como uma avaliação de
funções matemáticas, evitando estados ou
dados mutáveis.
FUNCIONAL
Programador modela o problema por meio
de assertivas em relação aos objetos do
universo em questão: Exemplo: SQL e
HTML.
DECLARATIVA
PROCEDURAL
É baseado no conceito de chamadas a
procedimentos, conhecidos como rotinas,
sub-rotinas, métodos. Um conjunto de
passos computacionais a serem
executados. Procedimentos podem ser
chamados a qualquer momento durante a
execução do programa, inclusive por outros
procedimentos.
POO
Programação Orientada a Objetos é um
modelo de análise, projeto e programação
de software, baseado na composição e
interação entre várias unidades conhecidas
como objetos.
A troca de mensagens ocorre entre objetos, que são organizados de maneira hierárquica - por
tipo, função, características, entre outros - para aproximar o máximo possível tanto a linguagem
como o funcionamento da computação do mundo real. Ou seja, a organização desse tipo de
programação é similar àquela “que as pessoas utilizam para descrever objetos do mundo real” .
Na POO, todos os componentes de um programa são considerados objetos e todos os objetos
possuem estado, identidade, comportamento.
Reduzir os programas em partes resulta em metas mais fáceis de se alcançar. Os programas são
basicamente interações entre objetos, o que faz com que surjam padrões comuns. 
CONCEITOS ASSOCIADOS
Objetos correspondem a elementos da vida real e classes agrupam esses objetos. Assim, quando
falamos de carro, e só de carro, estamos falando de uma classe. Isso porque não especificamos as
características do veículo, então, várias características podem estar contidas - o que importa é que se trata
de um carro. Em cada classe, temos atributos, objetos que se referem a elas. Em relação aos métodos,
ou seja, o que o objeto reúne em termos de regras sobre seus atributos e operações. Ele diz ao objeto
como ele deve se comportar com o recebimento da mensagem. Os próprios métodos são objetos em si.
Portanto, a vantagem desse tipo de organização é permitir que o programa altere um objeto em si,
iidentificando-o dentro de uma classe e solicitando uma a lteração do método, a partir de uma
mensagem. “Os métodos podem ter parâmetros para fornecer informações adicionais para uma tarefa” . 
 Tome como exemplo os famosos métodos set e get. O primeiro sinaliza que uma informação está
sendo enviada. Já o segundo aponta uma informação sendo recebida. Getters e Setters são funções que
tornam possível OBTER e ALTERAR o atributo.
Generalização e Especialização: 
Quando um objeto é identificado com atributos e operações semelhantes em nosso sistema, diz-se que
pode ser agrupado em uma classe. Este processo é chamado de generalização. Por outro lado, pode
ocorrer que um objeto, ao ser identificado, constitua-se, na verdade, de uma classe de objetos, visto que
dele podem se derivar outros objetos. Já esse processo é chamado de especialização.
TIPOS DE OBJETO
ABSTRAÇÃO: 
Escondemos detalhes não essenciais, embora mostramos o que é mais relevante .
ENCAPSULAMENTO:
É a capacidade de juntar um determinado tipo de programa em partes, ou seja, o software tem
pedaços isolados entre si, que podem ser acessados de modo independente. O resultado disso
é a garantia de mais flexibilidade e facilidade quando surgem modificações nos programas, por
exemplo. A parte interna de um código não fica acessível para outras partes, com o intuito de
proteger e manter a sua integridade. Todas as operações a serem feitas pelo usuários devem ser
feitas por uma interface bem definida. Apresenta diversas camadas de abstração, dependendo
do que é relevante. 
1. Objetos tangíveis.
2. Incidente (evento ou ocorrência).
3. De interação (transação ou contrato).
Classes Públicas e Privadas:
Naturalmente, uma classe que inicie com
o termo public significa que é pública. Um
atributo, ou seja, um objeto que é iniciado
com private é visível apenas à classe
pertencente
COMO ACONTECE A COMPILAÇÃO EM JAVA?
1. Criação de um programa Java
Inserção de códigos pelo programador usando um editor
2. Compilação do programa Java em bytecodes
O compilador vai transformar o codigo.java em código.class (bytecodes), que
representam as tarefas a serem executadas na fase de execução. A vantagem
dos bytecodes é que eles são portáveis e independem de plataforma
3. Carrega o programa Java em memória
A Java Virtual Machine (JVM) armazena o programa em memória para executá-
lo, efetuando o seu carregamento. O carregador de classe, pega o .class que
tem os bytecodes do programa e os transfere para a memória principal
4. Verificar os bytecodes 
Enquanto as classes são carregadas, o verificador examina seus
bytecodes para ter certeza que são válidas.
5.Executar o programa Java
A JVM executa os bytecodes utilizando uma combinação de
interpretação (Just in Time), conhecido como compilador Java
HotSpot. O Java HotSpot traduz os bytecodes para a linguagem
de máquina, quando a JVM encontra novamente essas partes
compiladas.
NÍVEIS DE ACESSO
Privada não visível a nenhuma classe externa; visível apenas dentro da classe
Pública: completamente visível internamente e para outras classes e elementos externos
Protegida: não visível a classes e elementos externos; visível apenas dentro da classe e para seus herdeiros.
Private: visível exclusivamente dentro da classe. Public: completamente visível dentro e fora da classe
Protected: visível apenas dentro da classe, pelos seus herdeiros e pelas classes no mesmo pacote
Padrão: visível apenas dentro da classe e pelas classes que estão no mesmo pacote.
class MeuPrograma {
 public static void main(String[] args) {
 System.out.println("Minha primeira aplicação Java!");
 }
}
Aprender sobre os principais conceitos da Programação Orientada a Objetos: classes e objetos;
Diferenciar o conceito de encapsulamento e o mecanismo de ocultação de informação para desenvolver
programas com maior qualidade, flexibilidade e futuras modificações.
SEMANA 2
OBJETOS: entidade que é capaz de salvar estado
(informação) e que oferece um conjunto de operações
(comportamentos) para verificar ou alterar esse
estado. Os objetos indicam o quão capaz é o sistema
de guardar informações sobre o que está sendo
abstraído e em seguida interagir com ele
Estado definido pelas propriedades
Comportamento definido pela forma
Identidade cada objeto é único
São uma forma de diminuir o gap
semântico.
EX
Pessoa
Atributos: nome, idade, altura 
Métodos: falar, comer, morder, dormir
Carro
Atributos: cor, tamanho, velocidade 
Métodos: ligar, desligar, acelerar, frear
É a instância de uma classe
CLASSE: é um molde para os objetos. As classes são moldes que permitem a criação de novosobjetos e descrevem as características comuns de vários objetos. Os objetos que pertencem a uma
classe. Eles são chamados de instâncias de classes
descreve um conjunto de objetos semelhantes 
MÉTODO: operações que podem ser executadas pelos objetos e dão acesso aos VALORES
DOS ATRIBUTOS.
CONSTRUTORES: Métodos com o mesmo nome da classe e não possui retorno
PILARES DA PROGRAMAÇÃO ORIENTADA AOS OBJETOS
POLIMORFISMO
É um princípio em que um organismo pode surgir de formas
distintas. Indivíduos da mesma espécie possuem
características similares. Em POO, a mesma operação (método)
comporta-se de modo diferente nas diferentes classes de uma
hierarquia
MENSAGENS
Quando um objeto emissor transmite uma
requisição para um objeto receptor para que este
execute um comportamento (método) desejado. O
objeto receptor precisa já ter os métodos definidos.
Os métodos respondem a um retorno à chamada. 
ABSTRAÇÃO
Ignora o que não é relevante e concentra-
se apenas nos aspectos principais do
problema. Classes são abstrações de
conceitos
ENCAPSULAMENTO
Capacidade de implementar dados e
procedimentos que se correlacionam numa
mesma entidade. A ideia é não depender
do funcionamento interno, mas sim da sua
interface
HERANÇA
Caracteriza-se pela
hierarquização das
classes em um
sistema.
NORMALMENTE os atributos são private. Desta forma, os métodos da própria classe é que são
responsáveis por modificar e recuperar o estado dos atributos 
• SETTERS e GETTERS são públicos. 
ENCAPSULAMENTO
EXEMPLO DE APLICAÇÃO
traz modularidade e ocultação da informação que indica a única parte do objeto que
pode ser acessada pelo mundo externo, deve ser feita por meio de operações.
“Na programação orientada a objetos, os objetos
comunicam-se entre si através de mensagens. A
única coisa que um objeto conhece sobre outro
objeto é a sua interface de comunicação. Os
dados e a lógica de cada objeto são mantidos
escondidos dos outros objetos. Em outras
palavras, a interface encapsula o código e os
dados do objeto”
Interface descreve como as partes do objeto se
relacionam com o exterior.
Implementação: dados e código que
implementam o comportamento dos objetos da
classe; esta parte não é visível externamente.
O encapsulamento é um conceito da POO em que os estados dos objetos (variáveis de classe) e seus
comportamentos (métodos da classe) são agrupados em conjunto segundo o seu grau de relação. 
Ocorre através de dois métodos: 
SETTERS: recebe como argumento uma informação que pode ser qualquer
tipo de dado suportado pela linguagem, o que evita acessos indevidos.
Servem para alterar a informação de uma propriedade de um objeto.
GETTERS: retorna o valor que lhe foi solicitado, mas não prejudica a
integridade do dado. Servem para retornar o valor dessa propriedade
cRIANDO MESSAGE BOX
Implemente a classe abaixo:
Classe Bola 
Atributos 
material → string 
cor → string 
tamanho → inteiro 
cheia → boolean 
Métodos 
Bola() → Construtor padrão 
Bola(String material, String cor, int tamanho, boolean cheia) –> sobrecarga 
Bola(String cor, int tamanho) → sobrecarga 
set (alterar atributos da classe → modificadores 
get (retorna valores dos atributos da classe - assessores) 
pintar() 
encher() 
esvaziar() 
Public: podem ser acessados de qualquer parte do programa que tenha uma referência ao objeto ou
subslasse de uma classe.
Private: só podem ser acessados dentro da própria classe a que eles pertencem. Por isto, eles não são
herdados por subclasses nem podem ser chamados por outros membros ligados a ela. 
Protected: nível intermediário que oferece permissões médias sendo possível garantir que os
membros de uma superclasse possam ser acessados apenas por subclasses e outros membros ligados
a ela. 
Membros protegidos: 
SEMANA 3
Aprender a criar novas classes a partir de classes já existentes,
aproveitando-se das características existentes na classe a ser estendida;
Entender que o conceito de polimorfismo permite ao desenvolvedor usar o
mesmo elemento de formas diferentes e que o conceito denota uma
situação na qual um objeto pode se comportar de maneiras diferentes ao
receber uma mensagem;
Compreender que interface é um recurso da linguagem Java que apresenta
inúmeras vantagens no sentido da modelagem e instanciação de objetos.
HERANÇA:
Uma nova classe de objetos pode ser criada por meio de herança - essa nova classe (chamada
de subclasse) começa com as características de uma classe existente (chamada superclasse)
através da sua personalização e adição de aspectos próprios. Em outras palavras, a herança é
uma maneira de reutilizar o código onde uma nova classe é criada absorvendo os membros
de uma classe já existente que são aprimoradas com novas ou melhores capacidades. 
Construtores em subclasses: o papel do construtor é
chamar o construtor da superclasse direta, especificando
os elementos que você deseja que façam parte da classe
herança. 
Generalização: quando várias subclasses utilizam os
mesmos atributos (elementos) de uma superclasse. 
Especialização: ocorre quando subclasses ligadas a
uma mesma superclasse apresentam diferenças entre
si. Por isso, é preciso especificar essas diferenças em
linha de código. 
Superclasses Abstratas: criadas apenas para
organizar a hierarquia das heranças que apesar de não
terem uma função ativa, ajudam a evitar a duplicação
do código. 
Vantagens da Herança:
Permite o reuso de software;
Sem a necessidade de escrever o mesmo código novamente;
Pode especializar soluções gerais já existentes;
Todo objeto da subclasse é um objeto da superclasse (classe mãe).
A classe filha herda todos os membros da classe mãe.
Podemos declarar um campo na classe filha com o mesmo nome da classe mãe, mesmo que os tipos sejam
diferentes.
Também podemos declarar novos métodos e campos na classe filha, o que denomina-se de
especialização.
Podemos sobrescrever um método da classe mãe, declarando um método com a mesma assinatura, o que
chamamos de polimorfismo
public class Carro {
private int velocidade;
public Carro(int velocidadeInicial) {
velocidade = velocidadeInicial;
}
public void acelera() {
velocidade++;
}
public void freia() {
velocidade--;
}
}
public class CarroCorrida extends Carro { 
public CarroCorrida(int velocidadeInicial) { 
super(velocidadeInicial); 
} 
public void acelera() {
 velocidade+=5; } 
} 
CarroCorrida x = new CarroCorrida(); 
x.acelera();
O importante é saber a definição do contrato 
Garantir que o software desenvolvido por um grupo se comunica com o outro por meio
deste contrato.
INTERFACE:
São coleções de métodos relacionados que normalmente permitem informar aos objetos o
que fazer, mas não como fazer. Uma classe implementa zero ou mais interfaces (cada uma
pode ter um ou mais métodos). É a especificação de um nome ou de um conjunto de métodos
que não define nenhuma implementação para os métodos ligados a ela. Interfaces não
possuem construtores e possuem visibilidade pública. 
O conceito principal de interface tem por objetivo criar um contrato em que a classe que a
implementa deve obrigatoriamente obedecer. Utilizamos a palavra reservada interface. 
No contexto de interface, quando programamos um software não importa como a
implementação será feita, pois:
POLIMORFISMO é a capacidade dos objetos responderem a uma mesma mensagem (chamada de
métodos) de modos distintos.
A JVM (Java Virtual Machine) procura a implementação mais especializada do método, seguindo a
hierarquia, ou seja, de baixo para cima. Da classe mais específica (filha) para a classe mais genérica (classe
mãe). Se o método não for definido na classe filha, procura-se pela implementação da classe mãe. •
Quando um método é sobrescrito na classe filha, ele passa a ter o comportamento padrão dessa classe,
embora seja possível acessar o método da superclasse.
Overriding: Quando isso ocorre, o método da classe mãe fica sobreposto.
SUPER: aproveitar o comportamento definido pela classe
mãe, chamamos a implementação da classe mãe. É usado
para acessar campos e métodos da superclasse (Campos
ocultos, Métodossobrescritos (polimorfismo) e Construtores
da superclasse).
THIS: pode ser usada para referenciar o próprio objeto,
permitindo distinguir variáveis locais e campos do objeto que
contém os mesmos nomes.
FINAL: Métodos final não podem ser sobrescritos. A palavra
chave final ou o modificador final significa que o método
definido com ela não poderá ser sobrescrito em uma
subclasse. Este modificador pode ser aplicado em classes,
métodos e atributos. Métodos privados são apenas acessíveis
dentro da classe definida, não sendo possível sobrescrever
um método private em uma subclasse, quando usamos o
modificador final.
public interface MinhaPrimeiraInterface {
public void metodo1();
public int metodo2();
public String metodo3(String parametro1);
}
As interfaces deixam também o código mais reutilizável, já
que uma única classe pode trabalhar com várias outras por
meio de uma única interface. Em interfaces, qualquer
método sempre é public. Para classes que não têm relação
entre si, ou seja, não há uma relação forte (herança), usa-se
interfaces
CLASSES ABSTRATAS
Usamos classes abstratas quando desejamos definir uma classe mais geral,
representando objetos de modo mais genérico, porém, sem instanciá-los.
Outro ponto importante é que métodos abstratos também podem ser
definidos em uma classe. Para isso, a classe precisa ser abstrata. Ela só não
pode ser instanciada. Se é preciso oferecer atributos, é melhor usar classes
abstratas, uma vez que com herança os atributos serão herdados.
abstract class Conta {
private double saldo;
public void setSaldo(double saldo) {
this.saldo = saldo;
}
public double getSaldo() {
return saldo;
}
public abstract void imprimeExtrato();
Implemente uma classe Caneta cujas
características são: marca, cor e tamanho.
Nesta classe devem ser implementados os
métodos construtores, getters, setters e
toString. Em seguida, em uma outra classe
denominada CanetaTeste crie um objeto do
tipo Caneta e atribua valores e exiba os
dados do objeto criado. 
Implemente uma classe Professor cujas propriedades são: matrícula e nome. Nesta classe devem ser
implementados os métodos construtores, getters, setters e um método para calcular o salário do
professor. Em seguida, implemente uma outra classe denominada ProfessorConcursado que herde as
características da classe Professor. Faça o mesmo para outra classe denominada ProfessorHorista. Para
ambas as classes implemente os métodos setters e getters também. Ainda no caso da classe
ProfessorHorista você deve implementar um método que calcule o salário em função do valor da hora e
da quantidade de horas. Para finalizar, implemente uma classe chamada TesteProfessor e exiba o salário
e matricula do professor concursado e do professor horista. 
Classes Empacotadoras: Essas classes chamam-se Boolean , Byte , Character , Double , 
 Float , Integer , Long e Short . Elas permitem manipular valores detipo primitivo como objetos.
as classes empacotadoras de tipo são classes final , então não é possível estendê-las.
Autoboxing e auto-unboxing: convertem automaticamente entre valores de tipo primitivo e objetos
empacotadores de tipo. Uma conversão boxing converte um valor de um tipo primitivo em um objeto
da classe empacotadora de tipo correspondente. Uma conversão unboxing converte um objeto de
uma classe empacotadora de tipo em um valor do tipo primitivocorrespondente.
 Interface Collection e classe Collections; a interface contém operações de volume (isto é,
operações realizadas na coleção inteira ) para operações como adicionar , limpar e comparar 
 objetos (ou elementos) em uma coleção. Uma Collection também poder ser convertida em um array.
Além disso, a interface Collection fornece um método que retorna um objeto Iterator , que permite
a um programa percorrer a coleção e remover elementos da coleção durante a iteração. A classe 
 Collections fornece métodos static que pesquisam, classificam e realizam outras operações sobre
as coleções.
Listas: é uma Collection ordenada que pode conter elementos duplicados. Comoos arrays, índices
de List são baseados em zero (isto é, o índice do primeiro elemento é zero). Além dos métodos
herdados de Collection , List fornece métodos para manipular elementos por meio de seus índices,
manipular um intervalo especificado deelementos, procurar elementos e obter um ListIterator para
acessar os elementos.A interface List é implementada por várias classes, inclusive as classes 
 ArrayList , LinkedList e Vector.
Método de Coleções: 
SEMANA 4
Desenvolver habilidades de programação ao entender sobre métodos
genéricos e classes genéricas;
Compreender a utilização de um conjunto bem definido de interfaces e
classes para representar e tratar grupos de dados como uma única
unidade, que é o que definimos como coleção ou collection.
COLEÇÕES: é uma estrutura de dados — na realidade, um objeto — que pode armazenar referências a
outros objetos. Normalmente, coleções contêm referências a objetos de qualquer tipo que tem o
relacionamento é um com o tipo armazenado na coleção. As interfaces de estrutura de coleções
declaram as operações a ser realizadas genericamente em vários tipos de coleções.
Genéricas: para eliminar o
problema das referências 
 Object obtidas de uma
coleção
As classes e interfaces da
estrutura das coleções são
membros do pacote java.util. 
coleção coleção em geral precisam sofrer downcast em um tipo apropriado para permitirem que o
programa processe os objetos corretamente. O downcasting deve ser evitado. Coleções Genéricos
permitem especificar o tipo exato que será armazenado em uma coleção e fornecem os benefícios da 
verificação de tipo em tempo de compilação — o compilador emite mensagens de erro se você usar
tipos inadequados nas coleções. Depois de especificar o tipo armazenado em uma coleção genérica,
qualquer referência que você recupera da coleção terá esse tipo. Isso elimina a necessidade de
coerções de tipo explícitas que podem lançar ClassCastExceptions se o objeto referenciado não for
do tipo apropriado. Além disso, as coleções genéricas são retrocompatíveis com o código Java que foi
escrito antes que genéricos tenham sido introduzidos.
Classe Stack: estende a classe Vector para implementar uma estrutura de dados de pilha.
Classe PriorityQueue e interface Queue: Lembre-se de que uma fila é uma coleção que representa
uma fila de espera — normalmente, inserções são feitas na parte de trás de uma fila e exclusões são
feitas a partir da frente. Na Seção 21.6, discutiremos e implementaremos uma estrutura de fila de
dados. Nesta seção, investigamos a interface Queue do Java e a classe PriorityQueue do pacote
java.util . A interface Queue estende a interface Collection e fornece operações adicionais para inserção,
remoção e inspeção de elementos em uma fila. PriorityQueue , que implementa a interface Queue ,
ordena elementos por sua ordem natural como especificado pelo método compareTo dos elementos
Comparable ou por um objeto Comparator que é fornecido pelo construtor.A classe PriorityQueue
fornece funcionalidades que permitem inserções na ordem de classificação na estrutura de dados
subjacente e exclusões a partir da frente da estrutura de dados subjacente. Ao adicionar elementos a
uma PriorityQueue , os elementos são inseridos na ordem de prioridade de tal modo que o elemento de
maior prioridade (isto é, o maior valor) será o primeiro elemento removido da PriorityQueue .As
operações PriorityQueue comuns são offer , para inserir um elemento na posição apropriada com base
na ordem de prioridade, poll para remover o elemento de mais alta prioridade da fila de prioridade (isto
é, a cabeça da fila), peek para obteruma referência ao elemento de mais alta prioridade da fila de
prioridade (sem remover esse elemento), clear para remover todos os elementos da fila de prioridade e
size , para obter o número de elementos da fila de prioridade.Set Não permite elementos duplicados
SortedSet Mantém os elementos ordenados
List Coleção de elementos ordenada, pode ter elementos duplicados e indexação. 
Qeue Representa uma fila genérica, FIFO. 
Deqeue Inserções e remoções podem ser feitas em qualquer extremidade
EM SÍNTESE
Métodos genéricos e classes genéricas (e interfaces) permitem especificar, com uma única declaração de
método, um conjunto de métodos relacionados ou, com uma única declaração de classe, um conjunto de
tipos relacionados, respectivamente. 
Iterator: Prover uma forma de seqüencialmente acessar os elementos de uma coleção sem expor sua
representação interna
Java Collections Framework: Arquitetura unificada para representar e manipular coleções,
de forma independente dos detalhes de sua representação.
As COLEÇÕES são objetos que agrupam vários elementos. Com as Collections utilizamos estruturas de
dados existentes, sem nos preocuparmos com a maneira como são implementadas. São dinâmicas, isto é,
podem crescer conforme a necessidade de expansão.
A interface Collection, terão obrigatoriamente que fazer a implementação de diversos métodos que
manipulam coleções de dados, tais como adicionar e remover elementos.
INTERFACE COLLECTION
A Collection é o topo da API Collections, sendo disponível no pacote java.util. As Collections podem ser
organizadas e/ou Ordenadas. Quando organizadas: garante que as coleções serão percorridas na mesma
ordem em que os elementos foram inseridos.
O padrão Generics é aceitar qualquer tipo de elemento, incluindo elementos distintos (String, Double,
Integer)
Set
HashSet: Armazena elemento numa tabela Hash e sem garantias de ordem dos
elementos
TreeSet: Utiliza uma estrutura de árvore para armazenar os elementos. Mantém a
ordem dos elementos
LinkedHashSet: Utiliza a tabela hash como uma lista ligada. Mantém a ordem de
inserções dos elementos
List
ArrayList: implementação indexada dos elementos
LinkedList: Utiliza uma lista duplamente encadeada para armazenar os elementos
Qeue
add e offer: inserem um elemento na fila
remove e pool: removem e retornam o elemento do início
element e peek: retornam, porém não removem, o elemento do início
Deqeue
Inserção: addFirst. offerFirst, addLast, offerLast
Remoção: removeFirst, poolFirst, removeLast, poolLast
For-each: Trata-se de um ciclo for, embora adaptado para ser utilizado em Collections. Server para
percorrer todos os elementos de qualquer Collection contida na API Collections.
Iterator: É uma interface presente no java.útil que permite percorrer coleções da API Collection, desde
que implementam a Collection. Fornece métodos como next(), hashnext(), remove(). 
A função de objetos do tipo Iterator é permitir percorrer e remover elementos de uma coleção. Toda
coleção possui um método que retorna um Iterator. Os métodos podem ser:
CLASSES CONCRETAS
hasNext() • Retorna true se há elementos a serem lidos no iterador
next() • Retorna o próximo elemento do iterador 
void remove() • Remove o último elemento obtido pela chamada de next() • Só é possível chamar uma
vez para cada chamada de next() • Se essa regra for desrespeitada, uma exceção é lançada
VANTAGENS: não depende do tipo de coleção • a Interface Collection provê método iterator() o
que permite criar uma solução genérica • Não são todas as coleções que têm um método de
remoção por índice como List e cada coleção possui uma maneira de percorrer os elementos
A classe Collections possui alguns métodos estáticos para manipular coleções
Sort: Classifica os elementos de uma List. 
binarySearch: Localiza um objeto em uma List. 
reverse: Inverte os elementos de uma List.
shuffle: Ordena aleatoriamente os elementos de uma List.
fill: Configura todo elemento List para referir-se a um objeto especificado. 
copy: Copia referências de uma List em outra.
•
min: Retorna o menor elemento em uma Collection. 
max: Retorna o maior elemento em uma Collection. 
addAll Acrescenta todos os elementos em um array a uma coleção. 
Implemente um programa em Java que é uma lista de animais, com
uma classe chamada ListaAnimais. Esta lista deve conter apenas 5
animais, que são: leão, cobra, gato sapo e cachorro. Utilize a classe
ArrayList ou LinkedList para construir essa lista. Adicione o leão, sapo
e cachorro na lista e exiba o resultado. Em seguida, adicione o gato na
posição 1 da lista e emita o resultado. Depois adicione a cobra e
emita o resultado. Para finalizar, ordene a lista em ordem crescente
dos elementos nela presente.
Considere agora que as necessidades da nossa lista de animais foram modificadas e que, precisamos, além
do nome do animal, o tipo e sua cor. Defina então uma classe denominada Animais e modifique a classe
ListaAnimais de maneira que a lista possa adicionar objetosAnimais ao invés de String. Ao final, exiba a lista
de animais. 
requency: Calcula quantos elementos na coleção são iguais ao elemento especificado. f
Disjoint: Determina se duas coleções não têm nenhum elemento em comum
GENERICS
Podemos reusar código para diferentes tipos e evita o uso de casting. Os tipos genéricos referem-se a uma
classe ou interface parametrizada sobre tipos. Em uma classe que não usa Generics, qualquer objeto pode
ser utilizado.
Declaração e Instanciação de um tipo genérico: 
Deve especificar qual o tipo desejado • É parecido à chamada de um método ou construtor, para qual
passamos parâmetros • Mas em Generics, o parâmetro é um tipo (classe ou interface)
É importante frisar que quando utilizado em métodos, o tipo genérico pertence ao escopo daquele
método. Não é possível utilizar o tipo em outros métodos. Não é possível instanciar um tipo genérico
utilizando tipos primitivos
COLEÇÕES
O programador simplesmente utiliza as estruturas de dados sem se preocupar com a maneira como são
implementadas. Basicamente, são objetos capazes de armazenar conjuntos de referências para outros
objetos 
INTERFACES: Definem métodos que podem ser usados para manipulação dos objetos nas
coleções
IMPLEMENTAÇÕES: Classes que implementam as interfaces, mas, internamente, manipulam os
dados de forma diferente
A importância dos genéricos: Quando o
compilador conhece o tipo do elemento da
coleção, ele pode verificar se a mesma está
sendo usada corretamente e pode inserir os
casts corretos nos valores recuperados da
coleção.
A importância dos iteradores: Quando se
trabalha com coleções, surge a necessidade
de manipular os objetos um a um. O
mecanismo de iteração A partir de uma
instância da classe que representa a coleção,
cria uma “maneira de visualizar” os objetos
contidos na coleção.
Um iterador é um padrão de projeto de
software que abstrai o processo de busca
sobre uma coleção de elementos
LISTA CONJUNTOS MAPA
A interface da lista permite elementos
duplicados Set não permite elementos duplicados.
O mapa não permite elementos
duplicados
A lista mantém o pedido de inserção. Definir não mantém nenhum pedido deinserção. 
O mapa também não mantém nenhum
pedido de inserção. 
Podemos adicionar qualquer número
de valores nulos.
Mas em conjunto quase apenas um
valor nulo.
O mapa permite no máximo uma única
chave nula e qualquer número de
valores nulos.
As classes de implementação de lista
são Array List , LinkedList .
As classes de implementação do
conjunto
são HashSet , LinkedHashSet e TreeSet .
 
As classes de implementação de mapa
são HashMap , HashTable , TreeMap , C
oncurrentHashMap e LinkedHashMap .
A lista fornece o método get() para
obter o elemento em um índice
especificado.
Set não fornece método get para obter
os elementos em um índice especificado
O mapa não fornece o método get para
obter os elementos em um índice
especificado
Se você precisa acessar os elementos
com frequência usando o índice,
podemos usar a lista
Se você deseja criar uma coleção de
elementos únicos, podemos usar o
conjunto
Se você quiser armazenar os dados na
forma de par chave / valor, podemos
usar o mapa.
Para percorrer os elementos da lista
usando Listlterator.
O iterador pode ser usado através dos
elementosdefinidos
Por meio do conjunto de chaves, valor
e conjunto de entrada.
SEMANA 5
Adquirir habilidades para a construção programas com a utilização das
interfaces Set e Map;
Entender e praticar o uso do TreeSet, TreeMap, HashSet e HashMap.
RETOMANDO
Uma coleção é uma estrutura de dados
que permite armazenar vários objetos.
Em Java , a coleção também é um objeto
As operações que podem ser feitas em
coleções variam mas normalmente
incluem: • Adição de elementos; •
Remoção de elementos; • Acesso aos
elementos; • Pesquisa de elementos;
Os três grandes tipos de coleções
são: • Lista ( também chamado de
“sequência“); • Conjunto; • Mapa(
também chamado de “dicionário“). 
ArrayList: implementa uma lista de objetos num vetor cujo tamanho pode variar dinamicamente (!). é mais
adequada em situações onde o acesso aleatório aos elementos é mais freqüente. A implementação do vetor
de ‘tamanho variável’ é cara.
LinkedList: implementa uma lista de objetos sob a forma de uma lista ligada, é mais adequada em casos
onde o acesso aleatório não é freqüente e o tamanho da lista pode variar muito.
CO
N
JU
N
TO
S:
 
Um conjunto funciona de forma análoga aos conjuntos da matemática
Trata-se de uma Collection que não permite elementos duplicados
A ordem em que os elementos são armazenados pode não ser a mesma ordem em que os
elementos foram inseridos no conjunto 
Ao percorrer um conjunto a sua ordem não é conhecida 
Velocidade na pesquisa de dados é mais rápida que um objeto do tipo List; 
Não precisa especificar a posição para adicionar um elemento; 
Não aceita valores duplicados. Se caso inserir um registro que já tenha no Set não será
adicionado.
HashSet: A classe HashSet que é implementada na estrutura de coleta é uma implementação inerente da
estrutura de dados da tabela de hash . Os objetos que inserimos no HashSet não garantem que sejam
inseridos na mesma ordem. Os objetos são inseridos com base em seu hashcode. Esta classe também
permite a inserção de elementos NULL. Vamos ver como criar um objeto definido usando esta classe.
LinkedSet: A classe LinkedHashSet que é implementada na estrutura de coleções é uma versão ordenada
de HashSet que mantém uma lista duplamente vinculada em todos os elementos. Quando a ordem de
iteração precisa ser mantida, essa classe é usada. Ao iterar por meio de um HashSet, a ordem é imprevisível,
enquanto um LinkedHashSet nos permite iterar através dos elementos na ordem em que foram inseridos.
Vamos ver como criar um objeto definido usando esta classe. 
TreeSet: A classe TreeSet que é implementada na estrutura de coleções e a implementação da Interface
SortedSet e SortedSet estende a Interface Set. Ele se comporta como um conjunto simples, com a exceção
de que armazena elementos em um formato classificado. TreeSet usa uma estrutura de dados em árvore
para armazenamento. Os objetos são armazenados em ordem crescente. Mas podemos iterar em ordem
decrescente usando o método TreeSet.descendingIterator().
https://acervolima.com/colecoes-em-java/
https://www.geeksforgeeks.org/data-structure-gq/hash-gq/
https://acervolima.com/colecoes-em-java/
https://www.geeksforgeeks.org/doubly-linked-list/
https://acervolima.com/colecoes-em-java/
https://acervolima.com/interface-sortedset-em-java-com-exemplos/
Object put(Object key, Object value): associa uma chave a um valor no mapa. Se a chave
já estiver presente o novo valor substitui o anterior e retorna o valor antigo ou null, caso
a chave não esteja presente corresponde ao método add(Object obj) de Collection 
Object get(Object key) recupera um objeto associado a uma chave ou null caso a chave
não exista
Mapa é um tipo especial de coleção que armazena pares de objetos (chave + valor)
Principais métodos:
package br.com.POO;
import java.util.HashSet;
import java.util.set;
public class Main{
public static void main(String[] args){
Set<String> cargos = new HashSet<>();
cargos.add("Gerente");
cargos.add("Diretor");
cargos.add("Presidente");
cargos.add("Secretária");
cargos.add("Funcionário");
cargos.add("Diretor");
// imprime na tela todos os elementos
System.out.println(cargos);
Declaração
M
A
PS
Declaração
package br.com.POO;
import java.util.HashMap;
import java.util.Map;
public class Main{
 class TestInterfaceMap {
public static void main(String[] args) {
Map<integer, string=""> mapNames = new HashMap<integer, string="">();
mapaNomes.put(1, "UNIVESP");
mapaNomes.put(2, "USP");
mapaNomes.put(3, "UNICAMP");
mapaNomes.put(3, "UNESP");
System.out.println(mapNomes);
//resgatando o nome da posição 2
System.out.println(mapaNomes.get(2));
}
}
HashMap: não garante a ordem das chaves, é a implementação da interface
Map, Os elementos não são ordenados, É rápida na busca e inserção de
dados e Permite inserir valores e chaves nulas.
Hashtable: utiliza hashing, Algoritmo para determinar uma chave na tabela,
Chaves nas tabelas possuem valores associados (dados), cada célula na
tabela é um recipiente de hash, Lista vinculada de todos os pares
chave/valor que sofrem hash para essa célula e Minimiza colisões.
TreeMap: Adição e a recuperação dos dados é igual à do
HashMap, Os dados no TreeMap são ordenados pela chave ,
Apenas os valores armazenados podem ser nulos, mas a chave
não e TreeMap é uma implementação baseada em árvore e Os
elementos são classificados de acordo com a ordem natural de
suas chaves, A classe TreeMap implementa a interface e Map
semelhante à classe HashMap. A principal diferença entre elas é
que o HashMap é uma coleção não ordenada, enquanto o
TreeMap é classificado na ordem crescente de suas chaves.
Exemplo com HashTable
public class HashtableExample {
public static void main(String[] args) {
Enumeration names;
String key;
// Cria a tabela hash
Hashtable<String, String> hashtable = new Hashtable<String, String>();
// Adiciona o par chave/valor
hashtable.put("Chave1","UNIVESP");
hashtable.put("Chave2","USP");
hashtable.put("Chave3","UNICAMP");
hashtable.put("Chave4","UNESP");
hashtable.put("Chave1","Mona");
names = hashtable.keys();
while(names.hasMoreElements()) {
key = (String) names.nextElement();
System.out.println("Chave: " +key+ " & Valor: " + hashtable.get(key));
}
}
}
public class TestTreeMap {
public static void main(String args[]) {
//Declaração do TreeMap
TreeMap<Integer, String> tmap;
tmap = new TreeMap<Integer, String>();
//Adiciona elementos
tmap.put(1, "UNIVESP");
tmap.put(7, "USP");
tmap.put(6, "UNICAMP");
tmap.put(4, "UNESP");
tmap.put(5, "UFMG");
// Mostra o conteúdo usando o Iterator Set
set = tmap.entrySet(); Iterator iterator =
set.iterator(); while(iterator.hasNext()) {
Map.Entry mentry =
(Map.Entry)iterator.next();
System.out.print("A chave é: "+
mentry.getKey() + " & O valor é: ");
System.out.println(mentry.getValue()); } } }
TRATAMENTO DE EXCEÇÕES
DIFERENÇA
ERRO EXCEÇÃO
indicam que algo grave o suficiente
deu errado, o aplicativo deve travar
em vez de tentar lidar com o erro
são eventos que ocorrem no código.
Um programador pode lidar com
tais condições e tomar as ações
corretivas necessárias.
SEMANA 6
Aprender a controlar exceções e tomar decisões baseadas nas mesmas;
Criar novos tipos de exceções para melhorar o tratamento delas em sua
aplicação ou biblioteca;
Definição de Exceção: Uma exceção é um evento indesejado que interrompe o fluxo normal do
programa. Quando ela ocorre, a execução do programa é encerrada.
é um dos recursos mais importantes da programação Java que nos permite tratar
os erros em tempo de execução causados por exceções.
O tratamento de exceções se refere aos erros em tempo de execução 
Sempre que um erro ocorre, uma exceção (objeto) é criada e lançada, a exceção (objeto) encapsula
as informações do erro. Essa exceção deve ser capturada em algum momento 
O método utilizado no JAVA é o bloco try-catch, try-catch-finally
Processo: quando ocorre uma exceção, o método cria um objeto de exceção e passa para o sistema
de runtime do java (lança a exceção). A execução do programa congela naquele ponto e o runtime
procura o trecho de código mais próximo que sejacapaz de capturar uma exceção daquele tipo. Se a
busca chegar ao main e não encontrar quem capture a exceção, o programa termina.
Tipos de Exceção
Todas as exceções, exceto Runtime Exceptions, são conhecidas como exceções
verificadas, pois o compilador as verifica durante a compilação para ver se o programador
as manipulou ou não. Se essas exceções não forem tratadas / declaradas no
programa, você obterá um erro de compilação. Exemplos: SQLException,
IOException, ClassNotFoundException etc. São criadas prevendo que determinada ação
possa falhar 
CHECKED
UNCHECKED As exceções de tempo de execução também são conhecidas como exceções não
verificadas. Essas exceções não são verificadas em tempo de compilação, então o
compilador não verifica se o programador as manipulou ou não, mas é responsabilidade
do programador lidar com essas exceções e fornecer uma saída segura. Exemplos:
ArithmeticException, NullPointerException, ArrayIndexOutOfBoundsException. Todas as
subclasses da segunda categoria estão ligadas à classe-padrão RunTimeException.
Exception: Precisam ser tratadas, pois são
situações excepcionais em um programa que
podem ser contornadas.
indicam um erro de
programa, prevendo
falhas que não
deveriam acontecer em
uma operação normal.
FORMAS DE TRATAR EXCEÇÕES
RuntimeException: Representam erros
internos na aplicação, mas que em geral não
são tratáveis pelo programador (erros na
programação ou do API JAVA). 
Error: Representam erros externos à aplicação,
que não são contornáveis pelo programador
(Falha na leitura de um arquivo por um
problema de hardware). 
Todo código em Java que pode gerar exceções deve lidar
com essas exceções de duas possíveis maneiras:
TRY-CATCH THROWS
Declarando um bloco try-catch dentro do método,
para tratar a exceção. 
Declarar que o método lança (throws) os tipos
de exceção que o código gera, delegando o
tratamento para outro nível na pilha (repassa o
erro)
Se nenhuma das duas alternativas for implementada, o código não compila. Nem todas as
exceções devem ser obrigatoriamente tratadas (lançadas), pois depende do tipo.
TRY: Contém um conjunto de instruções onde uma exceção pode
ocorrer. É sempre seguido por um bloco catch, que trata a
exceção que ocorre no bloco try associado.
CATCH: É onde lidamos com as exceções, deve seguir o bloco try.
Um único bloco try pode ter vários blocos catch associados a ele.
É possível capturar diferentes exceções em diferentes blocos de
captura, quando ocorre uma exceção no bloco try, o bloco catch
correspondente que trata essa exceção específica é executado. 
Quando uma exceção é lançada, o fluxo do
programa é interrompido naquele instante. Caso
esteja dentro de um try, a execução é deslocada
para o bloco catch que captura aquele tipo de
exceção. Caso não haja o bloco try-catch é
porque o método lança aquele tipo de exceção.
Neste caso, o método retorna levando a exceção
para quem o chamou. Caso não ocorra exceção,
apenas o bloco try é executado, pulando os blocos
catch e prosseguindo com a execução do programa.
FINALLY: Também é possível definir um bloco finally (é opcional)
em adição aos blocos try e catch. Sempre será executado,
independente do desfecho. É utilizado em geral, para códigos de
limpeza e finalização.
Exemplo de Implantação
Ex
em
plo
 co
m 
vá
rio
s b
loc
os
 ca
tch
Exe
mp
lo c
om
 try
/ca
tch
/fin
ally
REPASSAR EXCEÇÃO: Caso não
desejamos capturar e tratar
exceções, podemos repassá-las
na pilha de chamadas. Para isso,
o método precisa ser
explicitamente declarado que
lança um ou mais tipos de
exceções. Obrigatório
para o tipo checked. 
STREAMS
SEMANA 7
Aprender como desenvolver aplicações com streams, e entender a
importância de serializar/desserializar objetos em Java, aplicadas para
facilitar o uso das operações de entrada/saída, que é o caso da
comunicação via redes de computadores;
Aprender a criar e manipular threads em aplicações que utilizem a
linguagem Java;
Aprender o que são sockets, como criá-los e utilizar sockets em aplicações
distribuídas, utilizando o paradigma cliente-servidor.
Representam o fluxo contínuo de dados de entrada e saída. Baseiam-se no fluxo unidirecional de
dados, podendo ser de diferentes tipos (primitivos ou objetos). 
STREAM DE BYTE: De baixo nível,
descendem de InputStream e OutputStream.
STREAM DE CHAR: Descendem de Reader e
Writer. 
Stream de bytes faz a leitura e Stream de caracteres converte o dado que foi lido para caracteres. Não usam 
buffer o que torna o processo mais lento. 
usa buffers de memória
• Leitura: Requisitou dado pra ler, pega do buffer.
Quando o buffer esvaziar, novos dados serão
carregados do arquivo para o buffer
• Escrita: Requisitou a escrita de um dado, escreva
dados no buffer. Quando o buffer estiver cheio, os
dados serão descarregados para o arquivo
BufferedInputStream (byte)
BufferedOutputStream (byte)
BufferedReader (caracteres)
BufferedWriter (caracteres)
STREAM DE OBJETO: objetos inteiros podem ser lidos ou
escritos (gravados). Um objeto pode converter diversos
campos de tipos primitivos ou outros tipos objetos. Estes
também podem conter outros objetos ObjectInputStream
• ObjectOutputStreamSTREAM DE API: introduzido no JAVA 8 e usado para
processar coleções de objetos
Streams não alteram a estrutura de dados original, eles apenas fornecem o resultado de acordo
com os métodos em pipeline.
Operações para Intermediação: map (usado para retornar um fluxo que consiste nos resultados da
aplicação da função dada aos elementos deste fluxo), filtro (usado para selecionar elementos de acordo
com o Predicado passado como argumento) e ordenado (usado para ordenar o fluxo).
SERIALIZAÇÃO E DESSERIALIZAÇÃO
THREADS (lightweight processes - "processos leves")
Operações para lidar com Terminal: collect (usado para retornar o resultado das operações
intermediárias executadas no stream), forEach (itera em cada elemento do fluxo) e reduce (reduzir os
elementos de um fluxo a um único valor. O método de redução usa um BinaryOperator como parâmetro).
Utilizado para a leitura e gravação de objetos. O objeto serializado é representado como uma sequência de
bytes. Após a serialização, o objeto pode ser gravado utilizando o stream. Além disso é possível gravá-lo em
um arquivo, transportado por uma rede ou armazenado em um banco de dados.
Objetos serializados podem também serem desserializados, voltando a ser um objeto na memória.
A API de serialização Java fornece os recursos para realizar a serialização e desserialização.
Uma classe deve implementar a interface java.io.Serializable para ser elegível para serialização
A interface Serializable não possui métodos, sendo somente uma interface de marcação
Todos os tipos PRIMITIVOS são serializáveis.
A classe ObjectOutputStream é usada para serializar um objeto.
• O exemplo ExemploSerializacao instancia um objeto Funcionario e o objeto
é serializado em um arquivo.
• Após a execução do programa, ele cria um arquivo chamado
funcionario.ser.
• Este programa não tem saída, mas você pode ler o código para entender a
função de um programa.
• Importante: Quando um objeto é serializado para um arquivo, a convenção
do Java padrão é utilizar a extensão .ser
Em computação, problemas maiores são quebrados em problemas menores (processos pequenos) que
interagem entre si por meio da comunicação entre processos. A computação atual permite várias
linhas de execução em um mesmo processo THREADS. O problema é divido, limitando o custo de
comunicação entre processos (pois isso é custoso do ponto de vista computacional).
Time Slicing: Divisão do tempo de processamento entre várias linhas de execução
Processo: Instância de um programa que possui recursos básicos para ser executado (seu próprio
espaço de memória)
threads são independentes 
possuem sua própria pilha de execução 
Possuem seu próprio program counter e suas próprias variáveis locais.
necessitam de menos recursos computacionais do que os processos
No JAVA a principal é executada no método main 
Conceitos Importantes: 
CacaracterísticasImportantes:
Todo programa em Java é multithreaded
Um processo pode conter múltiplas threads que parecem executar ao mesmo tempo e de
forma assíncrona em relação às outras threads.
Todas as threads de um mesmo processo compartilham o mesmo espaço de endereçamento
de memória, o que significa que elas têm acesso às mesmas variáveis e objetos
É necessário que o desenvolvedor se assegure que uma thread não atrapalhe a execução de outra.
Por que usar?
Permite que o sistema operacional consiga dividir as tarefas entre todos os processadores disponíveis
aumentando, assim, a eficiência do processo.
Simplifica a modelagem
No processamento assíncrono (segundo plano) é possível atender a mais de um cliente ao mesmo tempo
Para criar uma thread no JAVA:
Criar um objeto que estende a classe Thread e
sobrescrevemos o seu método public void run(). Utiliza
herança:
Implementar a interface Runnable
MÉTODOS
PROGRAMAÇÃO JAVA PARA REDES DE COMPUTADORES
SOCKETS é um mecanismo de comunicação (dois sentidos) entre dois programas a funcionar
(normalmente) numa rede
No JAVA: 
DatagramaPacket - classe para
comunicação utilizando uma conexão não
confiável com o protocolo UDP;
 _Datagrama: é uma mensagem
independente e autocontida enviada pela rede,
cuja chegada, hora de chegada e conteúdo
não são garantidos
 Comandos: 
Socket e ServerSocket – são classes
que implementam, respectivamente, o
cliente e o servidor numa ligação
confiável com o protocolo TCP;
 _Socket: esconde todos os detalhes
particulares a cada sistema
 _ServerSocket: implementa a parte de
servidor
O uso dos métodos públicos get e set é importante para a programação orientada a objetos. Em
linguagem Java, esses métodos são criados para recuperar e atribuir, respectivamente, os valores aos
atributos de uma classe.
I. A importância do uso dos getters e setters está relacionada à proteção dos atributos de uma classe
frente a possíveis acessos indevidos que possam comprometer a integridade dos dados. 
II. Os métodos getters garantem a proteção dos atributos de acesso não autorizado e setters permitem a
criação de instruções validadoras dos dados, garantindo, assim, a integridade dos valores.
A programação declarativa utiliza palavras-chave, também conhecidas como tags ou assertivas, e é muito
utilizada como linguagens de marcação e para a busca de dados em bancos de dados, como a linguagem
SQL. A programação funcional é organizada em funções e utiliza a lógica tradicional de programação, sem
usar assertivas. A programação orientada a objetos trabalha com classes que funcionam como moldes
para os objetos existentes no mundo real. Na programação procedural o foco está na execução de
procedimentos.
Os programas desenvolvidos em linguagem Java podem usar ambientes integrados de desenvolvimento,
como Netbeans e Eclipse, para gerar os arquivos “.java”. Esses arquivos devem ser compilados, gerando
bytecodes, ou seja, arquivos “.class”. Esses arquivos serão carregados pela JVM (Java Virtual Machine) e
podem ser instalados nos mais diversos dispositivos e sistemas operacionais. 
A afirmativa I é verdadeira, pois o método “main” é responsável por tornar uma classe Java executável que
tenha um identificador válido. A afirmativa II é falsa, pois o método “main” deve ser usado uma única vez,
dentro de uma classe Java. A alternativa III é verdadeira, pois o método “main” deve ser declarado dentro
de uma classe que tenha um identificador válido, é declarado de forma pública, para que seja visto pelo
comando de execução da classe, e deve ser declarado como estático. A alternativa IV é verdadeira, pois o
método “main(String[] args)” tem o parâmetro “args”, que é um vetor de strings.
A programação orientada a objetos tem importantes características, dentre elas, os pilares, que permitem
a criação de sistemas de complexidade, com menor esforço e maior assertividade. O encapsulamento é
um desses importantes pilares. Nesse sentido, analise as asserções a seguir e a relação proposta entre
elas. I. O encapsulamento de um objeto ocorre com a proteção dos atributos, por meio dos modificadores
de acesso private ou protected. Esses atributos são externalizados por meio de métodos de acesso. O
encapsulamento independe de classes derivadas.
Os objetos instanciados podem ter valores distintos em seus atributos, pois, apesar de serem baseados
na mesma classe, ocupam endereços distintos na memória. Uma classe é um modelo para a geração de
objetos que representam entidades do mundo real. Como podemos ter diversas instâncias na memória
de um objeto, podemos ter valores diferentes em seus atributos. Um objeto é uma instância de uma
classe, que é um molde para o objeto, por isso, classes e objetos não são sinônimos, em programação
orientada a objetos.
Na programação orientada a objetos, os principais conceitos são os de classes e objetos. As classes são o
molde do objeto que, ao ser criado, terá os mesmos atributos e métodos, mas poderão assumir diferentes
valores para seus atributos.
O método “main” é público, porém seu retorno é vazio. Além disso,
quem realiza o cálculo é o método “calculo”. O funcionamento dos
métodos “main” e “calculo” é independente do seu tipo de retorno;
nesse caso, o método “main” é vazio e o método “calculo” retorna
um valor inteiro. Os parâmetros utilizados por qualquer método
são considerados variáveis locais ao método. No caso do método
“calculo”, as variáveis são do tipo inteiro. No código apresentado,
as variáveis “a” e “b” não foram declaradas como atributos da
classe, mas como parâmetros do método “calculo”. A linguagem
Java é case-sensitive, ou seja, os identificadores “Calculo” e
“calculo” são interpretados como distintos pela linguagem.
A afirmativa I é verdadeira, pois o encapsulamento melhora o entendimento do programa, permitindo a
visualização do que o programa faz, mas não, necessariamente, como faz. A afirmativa II é verdadeira, pois
o encapsulamento é utilizado para proteger uma classe inteira, podendo ser pública ou privada, deixando
visível somente o que for necessário. A afirmativa III é verdadeira, pois o encapsulamento determina de
que forma será o acesso dos atributos da classe, que podem ser públicos, privados ou protegidos. A
afirmativa IV é falsa, pois o encapsulamento define que os atributos sejam privados e os métodos de
acesso sejam públicos.
1 – String[]: III. Tipo de dados do parâmetro do método.
2 – public; I. Identificador da variável local utilizada como parâmetro do método.
3 – args: II. Modificador de acesso do método.
A proposição I está correta, pois a palavra-chave “final” pode ser atribuída a classes (nesse caso, essa
classe não poderá ser herdada). A proposição II está correta, mas não justifica a primeira, pois o termo
“final” também pode ser empregado em métodos que não poderão ser sobrescritos em subclasses e ser
também aplicados aos atributos, transformando-os em constantes que não podem ter seus valores
originais substituídos.
A herança é a possibilidade de as classes compartilharem atributos e métodos com outras classes,
construindo uma relação hierárquica. As afirmativas que tratam de associação, agregação, polimorfismo e
encapsulamento não têm similaridade com a herança, assim, não podem ser consideradas corretas.
Considerando a linguagem Java, com base na criação de uma subclasse “Onibus”, a partir de uma
superclasse “Transporte”, assinale a alternativa que apresenta o código correto.
public class Onibus extends Transporte
Na programação orientada a objetos, para que uma subclasse herde os atributos e métodos de uma
superclasse, é necessário utilizar o termo “extends”, que deve ser utilizado na definição da classe-filha:
public class Onibus extends Transporte. A classe que herda (filha) deve ser declarada antes da palavra
reservada “extends” e a superclasse deve ser declarada em seguida. Não se deve utilizar parênteses na
declaração de herança, pois não se trata de instanciação de um objeto. A palavra reservada “implements”
é utilizada para implementar métodos abstratos,ou seja, para outra finalidade, e não para herança.
A afirmativa I é verdadeira, pois um exemplo de polimorfismo ocorre quando um método da superclasse é
redefinido na subclasse ou quando um método tem o mesmo identificador, com parâmetros diferentes. A
afirmativa II é verdadeira, pois, se o método for sobrescrito na classe-filha, o compilador executará o
método da subclasse, porém, se não for sobrescrito, executará o método da superclasse. A afirmativa III é
falsa, pois, para que ocorra polimorfismo em classes herdadas, é necessário que os métodos tenham a
mesma assinatura. A afirmativa IV é verdadeira, pois um método pode ter a mesma assinatura na classe-
mãe e na filha e pode ter o comportamento diferente em ambas. No caso de ser um método sobrescrito
na classe-filha, esse será o novo comportamento do método.
A afirmativa I é verdadeira, pois, com o paradigma da herança, é possível declarar atributos com os
mesmos identificadores, porém com tipos diferentes; a linguagem interpreta o tipo de dado mais
especializado. A afirmativa II é verdadeira, pois, ainda com base nesse conceito, também é possível que
uma classe-filha sobrescreva um método definido na classe-mãe. A afirmativa III é verdadeira, pois a
classe-filha pode ter novos atributos ou métodos não presentes na classe-mãe. A afirmativa IV é
verdadeira, pois, ao herdar uma classe, a subclasse herda todos os atributos e métodos da classe-mãe.
1 – extends.: III. Termo utilizado na classe-filha para herdar a classe-mãe.
2 – super: I. Termo utilizado para chamadas do construtor da classe-mãe.
3 – this.II. Termo utilizado para referenciar um atributo externo fora de um método.
O código apresentado mostra um exemplo de polimorfismo estático,
em que existe uma sobrecarga do método, que tem o mesmo
identificador, porém a quantidade de parâmetros ou os tipos de
dados dos métodos são diferentes. O tipo de polimorfismo utilizado
entre os métodos de classe-mãe e de filha, que devem ter a mesma
assinatura, é o polimorfismo dinâmico.
O código apresentado mostra um exemplo correto da interface
“Iterator” em uma lista, usando “Generics” <String>. Desse modo, o
formato de saída não precisa ser convertido para String, pois o
método “next()” retorna o tipo da lista.
hasNext(): retorna “true”, se há elementos a serem lidos no iterador;
next(): retorna o próximo elemento do iterador;
remove(): remove o último elemento obtido pela chamada de next(). 
A afirmativa I é verdadeira, pois a interface “Iterator” é utilizada para percorrer e remover elementos de
uma coleção, por meio de três métodos: 
A afirmativa II é verdadeira, pois todos os objetos herdados da classe “Collection” também herdam o
“Iterator”. A afirmativa III é falsa, pois o “For-each” não é um exemplo de aplicação da interface “Iterator”.
Apesar do For-each, quando aplicado a uma coleção do arcabouço de coleções, usar internamente um
iterador, esse iterador não está exposto ao usuário. Além disso, o "For-each" pode ser usado para
percorrer também Arrays simples e nesse caso não usa iteradores. A afirmativa IV é verdadeira, pois o
método “hasNext()” é utilizado para verificar a existência de elementos a serem percorridos em um objeto
“Collection”
1 – add e offer: III. Inserem um elemento na fila.
2 – remove e poll: I. Removem e retornam o elemento do início.
3 – element e peek.: II. Retornam, porém não removem, o elemento do início.
A sentença 1 se enquadra no conceito III, pois os métodos “add” e “offer” são responsáveis por inserir um
elemento na fila ou lista. A sentença 2 se enquadra no conceito I, pois os métodos “remove” e “poll”
removem e retornam o elemento do início. A sentença 3 se enquadra no conceito II, pois os métodos
“element” e “peek” retornam, porém não removem, o elemento do início.
Na programação orientada a objetos, o uso de classes e
métodos genéricos pode reduzir o código de programação e
prevenir erros, como é o caso do código apresentado. Utiliza-
se a notação <TipoDeDados> com o “Generics”, em linguagem
Java.
Na programação orientada a objetos, é comum o uso de classes e métodos genéricos, visando reduzir a
quantidade de códigos de conversão de tipos de dados.
List<Carro> carros = new ArrayList<Carro>()
Com uso de “Generics”, a lista pode somente ter objetos do tipo “Carro”, não aceitando objetos de outro
tipo, assim, é possível assegurar qual tipo será retornado pela lista, caso contrário, o erro será percebido
somente em tempo de execução.
I. Uma das vantagens de usar iteradores é que eles não dependem do tipo de coleção. 
II. Não são todas as coleções que têm um método de remoção por índice, como “List”, e cada coleção tem
uma maneira de percorrer os elementos.
A proposição I está correta, pois o uso de iteradores é uma grande vantagem, visto que todas as classes-
filhas de “Collection” implementam essa interface. A proposição II está correta, pois a classe “Collection”
tem algumas classes-filhas que não têm métodos de remoção por índice, como ocorre com a classe “List”
(uma das mais usadas em aplicações de sistemas de informação).