Programação

SEMANA 1
Orientada a Objetos
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.

PARADIGMAS DE COMPUTAÇÃO

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.

FUNCIONAL DECLARATIVA
Programadores abstraem o programa Programador modela o problema por meio
como uma sequência de funções de assertivas em relação aos objetos do
executadas de modo empilhado. Trata da universo em questão: Exemplo: SQL e
computação como uma avaliação de HTML.
funções matemáticas, evitando estados ou
dados mutáveis.
PROCEDURAL
POO É baseado no conceito de chamadas a
Programação Orientada a Objetos é um procedimentos, conhecidos como rotinas,
modelo de análise, projeto e programação sub-rotinas, métodos. Um conjunto de
de software, baseado na composição e passos computacionais a serem
interação entre várias unidades conhecidas executados. Procedimentos podem ser
como objetos. chamados a qualquer momento durante a
execução do programa, inclusive por outros
procedimentos.

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

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.
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.

Classes Públicas e Privadas:

1. Objetos tangíveis.
Naturalmente, uma classe que inicie com
o termo public significa que é pública. Um
TIPOS DE OBJETO 2. Incidente (evento ou ocorrência).
atributo, ou seja, um objeto que é iniciado
com private é visível apenas à classe
3. De interação (transação ou contrato).
pertencente

COMO ACONTECE A COMPILAÇÃO EM JAVA?

1. Criação de um programa Java 4. Verificar os bytecodes

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
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.
 class MeuPrograma {
public static void main(String[] args) {
System.out.println("Minha primeira aplicação Java!");
SEMANA 2 }
}
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.
É a instância de uma classe
OBJETOS: entidade que é capaz de salvar estado Estado definido pelas propriedades
(informação) e que oferece um conjunto de operações Comportamento definido pela forma
(comportamentos) para verificar ou alterar esse Identidade cada objeto é único
estado. Os objetos indicam o quão capaz é o sistema
São uma forma de diminuir o gap
de guardar informações sobre o que está sendo
semântico.
abstraído e em seguida interagir com ele
Pessoa Carro
Atributos: nome, idade, altura Atributos: cor, tamanho, velocidade
EX Métodos: falar, comer, morder, dormir Métodos: ligar, desligar, acelerar, frear
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.
descreve um conjunto de objetos semelhantes
CLASSE: é um molde para os objetos. As classes são moldes que permitem a criação de novos
objetos 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
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

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.

PILARES DA PROGRAMAÇÃO ORIENTADA AOS OBJETOS

POLIMORFISMO ABSTRAÇÃO
É um princípio em que um organismo pode surgir de formas Ignora o que não é relevante e concentra-
distintas. Indivíduos da mesma espécie possuem se apenas nos aspectos principais do
características similares. Em POO, a mesma operação (método) problema. Classes são abstrações de
comporta-se de modo diferente nas diferentes classes de uma conceitos
hierarquia
ENCAPSULAMENTO
MENSAGENS Capacidade de implementar dados e
Quando um objeto emissor transmite uma
HERANÇA
procedimentos que se correlacionam numa
requisição para um objeto receptor para que este Caracteriza-se pela mesma entidade. A ideia é não depender
execute um comportamento (método) desejado. O hierarquização das do funcionamento interno, mas sim da sua
objeto receptor precisa já ter os métodos definidos. classes em um interface
Os métodos respondem a um retorno à chamada. sistema.
 traz modularidade e ocultação da informação que indica a única parte do objeto que
ENCAPSULAMENTO
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 Interface descreve como as partes do objeto se
única coisa que um objeto conhece sobre outro relacionam com o exterior.
objeto é a sua interface de comunicação. Os Implementação: dados e código que
dados e a lógica de cada objeto são mantidos implementam o comportamento dos objetos da
escondidos dos outros objetos. Em outras classe; esta parte não é visível externamente.
palavras, a interface encapsula o código e os
dados do objeto”
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

EXEMPLO DE APLICAÇÃO

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()
 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 SEMANA 3
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.
Membros protegidos:
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.
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
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.
public class Carro { SUPER: aproveitar o comportamento definido pela classe
private int velocidade; mãe, chamamos a implementação da classe mãe. É usado
public Carro(int velocidadeInicial) { para acessar campos e métodos da superclasse (Campos
velocidade = velocidadeInicial; ocultos, Métodos sobrescritos (polimorfismo) e Construtores
} da superclasse).
public void acelera() {
velocidade++; THIS: pode ser usada para referenciar o próprio objeto,
} permitindo distinguir variáveis locais e campos do objeto que
public void freia() { contém os mesmos nomes.
velocidade--;
} 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
public class CarroCorrida extends Carro { subclasse. Este modificador pode ser aplicado em classes,
public CarroCorrida(int velocidadeInicial) { métodos e atributos. Métodos privados são apenas acessíveis
super(velocidadeInicial); dentro da classe definida, não sendo possível sobrescrever
} um método private em uma subclasse, quando usamos o
modificador final.
public void acelera() {
velocidade+=5; }
}
CarroCorrida x = new CarroCorrida();
x.acelera();
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:
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.
As interfaces deixam também o código mais reutilizável, já
public interface MinhaPrimeiraInterface { que uma única classe pode trabalhar com várias outras por
public void metodo1(); meio de uma única interface. Em interfaces, qualquer
public int metodo2(); método sempre é public. Para classes que não têm relação
public String metodo3(String parametro1); entre si, ou seja, não há uma relação forte (herança), usa-se
} interfaces
 Usamos classes abstratas quando desejamos definir uma classe mais geral,
CLASSES ABSTRATAS
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
abstract class Conta {
private double saldo; pode ser instanciada. Se é preciso oferecer atributos, é melhor usar classes
public void setSaldo(double saldo) { abstratas, uma vez que com herança os atributos serão herdados.
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.
 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 SEMANA 4
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.
As classes e interfaces da
estrutura das coleções são
membros do pacote java.util.
Genéricas: para eliminar o
problema das referências
Object obtidas de uma
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.
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:
 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.
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 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

 CLASSES CONCRETAS

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

Set
ordem dos elementos

LinkedHashSet: Utiliza a tabela hash como uma lista ligada. Mantém a ordem de
inserções dos elementos

ArrayList: implementação indexada dos elementos

List
LinkedList: Utiliza uma lista duplamente encadeada para armazenar os elementos

add e offer: inserem um elemento na fila

Qeue 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

Inserção: addFirst. offerFirst, addLast, offerLast

Deqeue
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:
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. min: Retorna o menor elemento em uma Collection.
binarySearch: Localiza um objeto em uma List. max: Retorna o maior elemento em uma Collection.
addAll Acrescenta todos os elementos em um array a uma coleção.
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.
•
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

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.
 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 Um iterador é um padrão de projeto de
instância da classe que representa a coleção, software que abstrai o processo de busca
cria uma “maneira de visualizar” os objetos sobre uma coleção de elementos
contidos na coleção.
 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. SEMANA 5
LISTA CONJUNTOS MAPA
RETOMANDO
A interface da lista permite elementos O mapa não permite elementos
Set não permite elementos duplicados.
duplicados duplicados

Uma coleção é uma estrutura de dados

Definir não mantém nenhum pedido de O mapa também não mantém nenhum
que permite armazenar vários objetos. A lista mantém o pedido de inserção.
inserção. pedido de inserção.

Em Java , a coleção também é um objeto O mapa permite no máximo uma única

Podemos adicionar qualquer número Mas em conjunto quase apenas um
As operações que podem ser feitas em de valores nulos. valor nulo.
chave nula e qualquer número de
valores nulos.

coleções variam mas normalmente

incluem: • Adição de elementos; •
Remoção de elementos; • Acesso aos
As classes de implementação de lista
são Array List , LinkedList .
As classes de implementação do
conjunto
As classes de implementação de mapa
são HashMap , HashTable , TreeMap , C
são HashSet , LinkedHashSet e TreeSet .
oncurrentHashMap e LinkedHashMap .

elementos; • Pesquisa de elementos;
Os três grandes tipos de coleções
A lista fornece o método get() para O mapa não fornece o método get para
Set não fornece método get para obter
obter o elemento em um índice obter os elementos em um índice
os elementos em um índice especificado
especificado. especificado

são: • Lista ( também chamado de
“sequência“); • Conjunto; • Mapa(
também chamado de “dicionário“).
Se você precisa acessar os elementos
com frequência usando o índice,
podemos usar a lista
Para percorrer os elementos da lista
usando Listlterator.
Se você deseja criar uma coleção de
elementos únicos, podemos usar o
conjunto
O iterador pode ser usado através dos
elementos definidos
Se você quiser armazenar os dados na
forma de par chave / valor, podemos
usar o mapa.
Por meio do conjunto de chaves, valor
e conjunto de entrada.

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.
Um conjunto funciona de forma análoga aos conjuntos da matemática
Trata-se de uma Collection que não permite elementos duplicados
CONJUNTOS:

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().
 Declaração
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);

Mapa é um tipo especial de coleção que armazena pares de objetos (chave + valor)
Principais métodos:
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
MAPS

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
Declaração

HashMap: não garante a ordem das chaves, é a implementação da interface

package br.com.POO;
Map, Os elementos não são ordenados, É rápida na busca e inserção de
dados e Permite inserir valores e chaves nulas.
import java.util.HashMap;
import java.util.Map;
Hashtable: utiliza hashing, Algoritmo para determinar uma chave na tabela,
Chaves nas tabelas possuem valores associados (dados), cada célula na
public class Main{
tabela é um recipiente de hash, Lista vinculada de todos os pares
chave/valor que sofrem hash para essa célula e Minimiza colisões.
class TestInterfaceMap {
public static void main(String[] args) {
Map<integer, string=""> mapNames = new HashMap<integer, string="">();
mapaNomes.put(1, "UNIVESP"); TreeMap: Adição e a recuperação dos dados é igual à do
mapaNomes.put(2, "USP"); HashMap, Os dados no TreeMap são ordenados pela chave ,
mapaNomes.put(3, "UNICAMP"); Apenas os valores armazenados podem ser nulos, mas a chave
mapaNomes.put(3, "UNESP"); não e TreeMap é uma implementação baseada em árvore e Os
System.out.println(mapNomes); elementos são classificados de acordo com a ordem natural de
//resgatando o nome da posição 2 suas chaves, A classe TreeMap implementa a interface e Map
System.out.println(mapaNomes.get(2)); 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.
 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()); } } }

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));
}
}
}
 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; SEMANA 6
é um dos recursos mais importantes da programação Java que nos permite tratar
TRATAMENTO DE EXCEÇÕES os erros em tempo de execução causados por exceções.

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.
DIFERENÇA
ERRO EXCEÇÃO
indicam que algo grave o suficiente são eventos que ocorrem no código.
deu errado, o aplicativo deve travar Um programador pode lidar com
em vez de tentar lidar com o erro tais condições e tomar as ações
corretivas necessárias.
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 seja capaz 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
CHECKED
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
As exceções de tempo de execução também são conhecidas como exceções não
UNCHECKED
verificadas. Essas exceções não são verificadas em tempo de compilação, então o
indicam um erro de
programa, prevendo
compilador não verifica se o programador as manipulou ou não, mas é responsabilidade
falhas que não do programador lidar com essas exceções e fornecer uma saída segura. Exemplos:
deveriam acontecer em
uma operação normal.
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.
 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

FORMAS DE TRATAR EXCEÇÕES
com essas exceções de duas possíveis maneiras:
TRY-CATCH THROWS
Declarando um bloco try-catch dentro do método, Declarar que o método lança (throws) os tipos
para tratar a exceção. 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

Exemplo de Implantação
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.
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.

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.
 tch
ca
c os
blo
s
rio
vá
m
co
o
pl
em
Ex

lly
na
/fi
tch
ca
t ry/
om
p loc
x em
E
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.

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
SEMANA 7
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.

STREAMS
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, STREAM DE CHAR: Descendem de Reader e
descendem de InputStream e OutputStream. 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.• Escrita: Requisitou a escrita de um dado, escreva
Quando o buffer esvaziar, novos dados serão dados no buffer. Quando o buffer estiver cheio, os
carregados do arquivo para o buffer dados serão descarregados para o arquivo
BufferedInputStream (byte) STREAM DE OBJETO: objetos inteiros podem ser lidos ou
BufferedOutputStream (byte) escritos (gravados). Um objeto pode converter diversos
BufferedReader (caracteres) campos de tipos primitivos ou outros tipos objetos. Estes
BufferedWriter (caracteres) também podem conter outros objetos ObjectInputStream
STREAM DE API: introduzido no JAVA 8 e usado para • ObjectOutputStream
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).
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).

SERIALIZAÇÃO E DESSERIALIZAÇÃO

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

THREADS (lightweight processes - "processos leves")

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).
Conceitos Importantes:
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)
Todo programa em Java é multithreaded
Cacaracterísticas Importantes:
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
 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:
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

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:
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.
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:
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 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).