OOP JAVA (PROVA)

1.0 CLASSE
Classe é uma maneira de se criar um objeto que possui o mesmo comportamento e a
mesma estrutura. Classe é uma estrutura que define: os dados; métodos que operam
sobre os dados e formam o comportamento de um objeto; o mecanismo de instalação de
objetos.
Code:
Class Aluno {
// atributo
Private String Nome;
// métodos
Public void inserirNome(){
Nome = System.out.toString();
}
Public String recuperarNome(){
Return Nome;
}
}
Obs: private e pulic modificam a visibilidade ou acessibilidade de métodos, atributos e
classes.
Estrutura:
[modificardor] class identificador[tipoParametros][superclasse][superinterface]{[corpo
da classe]}
[] = elementos opcionais
Fora = obrigatórios

2.0 MODIFICADORES
ANNOTATION : anotação
PROTECTED E PRIVATE : modificadores de acesso
STATIC : modifica o ciclo de vida da instância. Usado em classes membro.
ABSTRACT E FINAL : hierarquia de classes.
STRICTFP : cálculos de ponto flutuando independentes da plataforma.
 Obs : alguns desses modificadores podem ser usados com outros, como: public abstract
class teste {}.

3.0 SUPERCLASSE
SUPERCLASSE : assim como a “superinterface” permite ao java implementar a
herança entre classes e interfaces. O elemento superclasse será sempre do tipo “extends
identificadorClasse” (subclasse do identificador classe).
SUPERINTERFACE : e sintaxe é implements, ela implementa a interface
identificadorInterface.

4.0 OBJETOS E PRODUTOS DAS CLASSES

Nem toda classe permite a criação de um objeto, como por exemplo a classe
abstrata, a classe abstrata não permite instanciação direta.
O que é instanciar?
Instanciar uma classe significa realizar o modelo e essa realização se chama objeto.
Ciclo de vida de um objeto:
I. Uma var é declarada como sendo tipo de uma classe
II. Após, o compilador é instruído a gerar um objeto a partir dessa classe que será
rotulado como um identificador.
Code:
// as duas etapas citadas a cima
Aluno objetoAluno = new Aluno();
// mas também pode ser separado
Aluno objetoAluno; // declaração
objetoAluno = new Aluno(); // instanciação
III. Criação de um objeto começa com a alocação de um espaço de memória
IV. Prossegue com a execução do código de construção do objeto. (construtor)

5.0 CONSTRUTOR
O método construtor é sempre executado quando a instanciação de um objeto e
obrigatoriamente deve ter o nome idêntico ao da classe. Pode ter modificador mas não
pode ter tipo de retorno. A nstrução new é sempre seguida da chamada ao construtor da
classe. Assim, a atribuição (=) inicializa a variável com o retorno com referencia para o
objeto de new.
6.0 CLONAGEM

Outra forma de instanciar u objeto é através da clonagem. Aqui copias idênticas de um

objeto são feitas através da copia do espaço de memoria, porém cada objeto clonado terá um
identificador diferente. A instanciação através do “new” é mais demorada que a clonagem.

Vale lembrar que um o estado de um objeto é definido pelos seus atributos, quanto
seu comportamento é determinado pelos seus métodos.

Code:

Aluno novoAluno = new Aluno( “carlos alberto”, 16)

Após várias etapas irá mostrar um novo objeto guardado na memoria chamavo
“novoAluno”. O estado desse objeto é definido pelas variáveis já seu comportamento é dado
pelos métodos.

O comportamento do modelado construtor permite a construção inicial do objeto.

Code:

novoAluno.definirNome(“rita”)

a variável “nome” será atualizada passando a valer “rita”, alterando assim o estado do
objeto. O compilador é informado que está sendo invocado o método “definirNome” do
objeto “novoAluno”.

Por fim, a vida do objeto acabe com sua destruição o que é necessário para reciclar
espaço de memoria. A JVM varre o programa verificando objetos que não estejam sendo mais
referenciados, caso não estejam a JVM destrói e libera memória. Para isso ser feito podemos
invocar o método “gc()” da biblioteca “System”. Porem, isso é apenas uma solicitação e não
uma ordem.

Método “finalize()” : recicla um objeto.

7.0 CLASSES DE EMCAPSULAMENTO DE CÓDIGO

Do ponto de vista de POO, o encapsulamento visa ocultar do mundo exterior os

tributos e funcionamento da classe, ou seja, os detalhes de implementação e variáveis ficam
isolados do resto do código. Parecido com visibilidade.

8.0 TRABALHANDO COM CLASSES E OBJETOS

As classes e objetos são trechos de código que refletem o produto da analise

formando um sistema.
 MODULO 2 HERANÇA : ASPECTOS ELEMENTARES

Herança : tipos de relação entre objetos e classe, baseado em um hierarquia.

Dentro dessa hierarquia as classes podem herdar características das outras
ou até mesmo transmitir as suas.
Superclasse : é a classe situada hierarquicamente acima das outras. (classe base/pai)
Subclasses : é a classe hierarquicamente a baixo. (classe derivada/filho)

A herança permite reunir os métodos e atributos de uma superclasse para as

classes filhas.
Uma alteração só precisa ser feita na classe pai automaticamente já será
propagada para o restante.
Obs : quando existe mais de uma superclasse é denominada herança múltipla, mas a
linguagem java não suporta para classes. Porém, a classe pode ter várias interfaces,
assim como ter mais de uma interface pai,
Generalização e especialização

Code herança em classes:

Public classes ProfessorComissionado extends Professor{}
 Professor deve ter uma superclasse Empregado
 Empregado deve declarar pessoa como sua superclasse

A sintaxe é análoga para o caso das interfaces, no entanto pode haver mais
de um identificador se superinterface,
Code :
Public interface ProfessorComissionado extends Professor, Diretor {}
Também, vale observar que todas as claases dependem direta ou
indiretamente da classe “object” disponível para qualquer classe criada.
Equals() : método da classe “object” usado para comparar dois objetos.
 Se uma classe for declarada sem estender nenhuma outra o compilador assume
que ela estende “object”
 Se ela estender uma superclasse, ela é descendente indireta de object.
 1.0 HERANÇA DE VISIBILIDADE

Quando dizemos que a classe “pessoa” é uma generalização da classe

“empregado” significa que ela possui atributos e comportamentos que podem ser
generalizados para outras subclasses. A subclasse pode sobescrever o comportamento
modelado na superclasse.

DEFALT : assumido quando nenhum modificador é usado. Visibilidade estrita ao

pacote.
PRIVADO : private, a visibilidade é restrita à classe.
PROTEGIDO : protect. Visibilidade restrita ao pacote e a todas as subclasses.
PUBLICO : public, não existe restrição de visibilidade.

O maior escopo é o global que embarca todo programa. Com isso, também
temos o pacote que define um espaço de nomes e é usado para agrupar classes
relacionadas. (organiza as classes pelas afinidades e previne conflito de nomes).
Um pacote é definido pela função “package” seguida do nome do pacote.
Co isso, todos as classes do mesmo pacote terão acesso aos elementos que tiverem a
acessibilidade DEFAULT.
Já o PRIVATE é mais restrito pois limita a visibilidade ao escopo da classe,
ou seja so posso ver na classe que foi declarado.
O acesso aos métodos e atributos da superclasse pode ser concedido pelo
PROTECT, pois restringe o acesso as classes do mesmo pacote, classes de outros
pacotes tem acesso a partir da herança.
PUBLIC fornece um escopo global, qualquer classe, qualquer ambiente de
desenvolvimento pode acessar as entidades declaradas como publicas,
 A herança afeta os modificadores de acessibilidade da seguinte maneira:
 Métodos e atributos declarados púbicos na superclasse devem ser públicos na
subclasse.
 Métodos e atributos declarados protegidos na subclasse devem ser protegidos ou
públicos, não podem ser privados.
Code:
public class Pessoa {
//Atributos
private String nome;
private int idade;
private Calendar data_nascimento;
private long CPF;
private Endereco endereco;

//Métodos
public Pessoa ( String nome , Calendar data_nascimento, long CPF ,
Endereco endereco ) {
this.nome = nome;
this.data_nascimento = data_nascimento;
this.CPF = CPF;
this.endereco = endereco;
atualizarIdade ();
}
protected void atualizarNome ( String nome ) {
this.nome = nome;
}
protected String recuperarNome ( ) {
return this.nome;
}
 protected void atualizarIdade ( ) {
this.idade = calcularIdade ();
}
protected int recuperarIdade ( ) {
return this.idade;
}
protected void atualizarCPF ( long CPF ) {
this.CPF = CPF;
}
protected long recuperarCPF ( ) {
return this.CPF;
}
protected void atualizarEndereco ( Endereco endereco ) {
this.endereco = endereco;
}
protected Endereco recuperarEndereco ( ) {
return this.endereco;
}
private int calcularIdade ( ){
int lapso;
Calendar hoje = Calendar.getInstance();
lapso = hoje.get(YEAR) - data_nascimento.get(YEAR);
if ( ( data_nascimento.get(MONTH) > hoje.get(MONTH) ) ||
( data_nascimento.get(MONTH) == hoje.get(MONTH) && data_nascimento.get(DATE)
> hoje.get(DATE) ) )
lapso--;
return lapso;
}
}

Pessoa é a superclasse pois ela contem atributos que são comuns ás subclasses.
Também, ela possui um construtor não vazio e as subclasses precisam passar para ela os
parâmetros exigidos. Isso é feito pela instrução super.

public class Empregado extends Pessoa {

//Atributos
protected String matricula;
private Calendar data_admissao , data_demissao;

public Empregado(String nome, Calendar data_nascimento, long CPF,

Endereco endereco) {
super(nome, data_nascimento, CPF, endereco);
this.matricula = gerarMatricula ();
data_admissao = Calendar.getInstance();
}
public void demitirEmpregado () {
data_demissao = Calendar.getInstance();
}
protected void gerarMatricula () {
this.matricula = "Matrícula não definida.";
}
protected String recuperarMatricula () {
return this.matricula;
}
}
public class Aluno extends Pessoa {
//Atributos
private String matricula;

//Métodos
public Aluno ( String nome , Calendar data_nascimento , long CPF ,
Endereco endereco ) {
super ( nome , data_nascimento , CPF , endereco );
}
}

public class Principal {

//Atributos
private static Aluno aluno;
private static Endereco endereco;

//Método main
public static void main (String args[]) {
int idade;
Calendar data = Calendar.getInstance();
data.set(1980, 10, 23);
endereco = new Endereco ();
endereco.definirPais("Brasil");
endereco.definirUF("RJ");
endereco.definirCidade ("Rio de Janeiro");
endereco.definirRua("Avenida Rio Branco");
endereco.definirNumero("156A");
endereco.definirCEP(20040901);
endereco.definirComplemento("Bloco 03 - Ap 20.005");
aluno = new Aluno ("Marco Antônio", data , 901564098 ,
endereco);
aluno.atualizarIdade();
idade = aluno.recuperarIdade();

}
}

2.0 HERANÇA, SUBTIPOS E O PRINCIPIO DA SUBSTITUIÇÃO DE LIAKOV

2.0 POLIMORFISMO

POLIMOSFISMO : capacidade de um objeto se comportar de diferentes maneiras.

O polimorfismo pode se expressar de diversas maneiras. Sobrecarga de

função assim como a herança são formas de dar ao objeto uma capacidade polimórfica,
o polimorfismo surge pois o objeto pode se comportar também como definido na
superclasse. Ex : considerando o objeto “Aluno”, todo objeto “aluno” é do tipo
“pessoa”, logo ele pode se comportar como “aluno” ou “pessoa”.
Todo objeto que possui subclasse tem capacidade de ser polimórfico, logo,
todo objeto java é polimórfico mesmo não estendendo outra classe.
O poliformismo permite o desenvolvimento de códigos facilmente
extensíveis, pois a classe pode ser adicionada com baixo impacto no software, basta que
as classes sejam derivadas daquelas que implementam comportamentos gerais.
Essas novas classes podem especializar os comportamentos da superclasse,
alterar sua implementação para refletir a sua especificidade e não impactará na
superclasse.
Code:
public class Diretor extends Empregado {
//Atributos

//Métodos
public Diretor(String nome, Calendar data_nascimento, long CPF,
Endereco endereco) {
super(nome, data_nascimento, CPF, endereco);
}
protected void gerarMatricula () {
matricula = "E-" + UUID.randomUUID( ).toString( );
}
}

public class Principal {

//Atributos
private static Empregado empregado , diretor;

//Método main
public static void main (String args[]) {

Calendar data = Calendar.getInstance();

data.set(1980, 10, 23);
empregado = new Empregado ("Clara Silva", data , 211456937 ,
null);
empregado.gerarMatricula();
diretor = new Diretor ("Marco Antônio", data , 901564098 ,
null);
diretor.gerarMatricula();
System.out.println ("A matrícula do Diretor é: " +
diretor.recuperarMatricula());
System.out.println ("A matrícula do Empregado é: " +
empregado.recuperarMatricula());
}
}

Saída :

A matrícula do Diretor é: E-096d9a3d-98e9-4af1-af61-

a03d97525429
 A matrícula do Empregado é: Matrícula não definida.

Polimorfismo também pode ser obtido por meio da sobrecarga de métodos.

Métodos com o mesmo identificador, mas diferentes parâmetros na mesma classe.
code:
public class Diretor extends Empregado {
//Atributos

//Métodos
public Diretor(String nome, Calendar data_nascimento, long CPF,
Endereco endereco) {
super(nome, data_nascimento, CPF, endereco);
}
protected void gerarMatricula () {
matricula = "E-" + UUID.randomUUID( ).toString( );
}
protected void alterarMatricula () {
gerarMatricula ();
}
protected void alterarMatricula ( String matricula ) {
this.matricula = matricula;
}
}
 MODULO 3 GRUPAMENTO DE OBJETOS
AGRUPAMENTO: permite que objetos sejam estabelecidos com base em determinado
critério.
Em um universo de objetos e os critérios de particionamento separar em
grupos tais que cada grupo todos os objetos possuam o mesmo valor para os critérios
escolhidos.
Sua implementação precisa ser observada a checagem de referência pra
evitar acessos ilegais pois teremos que usar uma lista de listas ou outra estrutura de
dados similar.

1.0 IMPLEMENTANDO AGRUPAMENTO DE OBJETOS

No agrupamento o estado final desejado é ter os objetos agrupados

Felizmente a javaAPI oferece estruturas que facilitam isso. Para manter e

manipulara objetos usaremos o container “LIST” que cria uma lista de objetos.
Para manter os pares de particionamento usa-se o container “MAP” que faz
o mapeamento entra a chave e um valor. Chave: critério de particionamento. Valor: lista
de objetos particionados.
Code:
public class Aluno {
//Atributos
private String matricula , nome , naturalidade;

//Métodos
public Aluno ( String nome , String naturalidade ) {
 this.nome = nome;
this.naturalidade = naturalidade;
}
@Override
public String toString () {
return String.format("%s(%s)", nome , naturalidade
);
}
}

class Escola {
//Atributos
private String nome, CNPJ;
private Endereco endereco;
private List departamentos;
private List discentes;

//Métodos
public Escola ( String nome , String CNPJ) {
this.nome = nome;
this.CNPJ = CNPJ;
this.departamentos = new ArrayList<Departamento> ( );
this.discentes = new ArrayList<Aluno> ( );
}
public void criarDepartamento ( String nomeDepartamento ) {
departamentos.add ( new Departamento ( nomeDepartamento ) );
}
public void fecharDepartamento ( Departamento departamento ) {
departamentos.remove ( departamento );
}
public void matricularAluno ( Aluno novoAluno ) {
discentes.add ( novoAluno );
}
public void trancarMatriculaAluno ( Aluno aluno ) {
discentes.remove ( aluno );
}
public void agruparAlunos ( ) {
Map < String , List < Aluno > > agrupamento = new HashMap <>
();
for ( Aluno a : discentes ) {
if(!agrupamento.containsKey
( a.recuperarNaturalidade ( ) )) {
agrupamento.put( a.recuperarNaturalidade ( )
, new ArrayList<>( ) );
}
agrupamento.get(a.recuperarNaturalidade ( ) ).add(a);
}
System.out.println ("Resultado do agrupamento por naturalidade: " +
agrupamento );
}
}

public class Principal {

//Atributos
private static Aluno aluno1 , aluno2 , aluno3 , aluno4 , aluno5 ,
aluno6 , aluno7 , aluno8 , aluno9;
private static Escola escola;
 //Método main
public static void main (String args[]) {
escola = new Escola ( "Escola Pedro Álvares Cabral" ,
"42.336.174/0006-13");
criarAlunos ();
matricularAlunos ();
escola.agruparAlunos();
}

//Métodos
private static void criarAlunos ( ) {
aluno1 = new Aluno ( "Marco Antônio" , "Rio de Janeiro" );
aluno2 = new Aluno ( "Clara Silva" , "Rio de Janeiro" );
aluno3 = new Aluno ( "Marcos Cintra" , "Sorocaba" );
aluno4 = new Aluno ( "Ana Beatriz" , "Barra do Pirai" );
aluno5 = new Aluno ( "Marcio Gomes" , "São Paulo" );
aluno6 = new Aluno ( "João Carlos" , "Sorocaba" );
aluno7 = new Aluno ( "César Augusto" , "São Paulo" );
aluno8 = new Aluno ( "Alejandra Gomez" , "Madri" );
aluno9 = new Aluno ( "Castelo Branco" , "São Paulo" );
}
private static void matricularAlunos ( ) {
escola.matricularAluno(aluno1);
escola.matricularAluno(aluno2);
escola.matricularAluno(aluno3);
escola.matricularAluno(aluno4);
escola.matricularAluno(aluno5);
escola.matricularAluno(aluno6);
escola.matricularAluno(aluno7);
escola.matricularAluno(aluno8);
escola.matricularAluno(aluno9);
}
}

Saída:

Resultado do agrupamento por naturalidade: {

São Paulo=[Marcio Gomes(São Paulo), César Augusto(São
Paulo), Castelo Branco(São Paulo)],
Rio de Janeiro=[Marco Antônio(Rio de Janeiro), Clara Silva(Rio de
Janeiro)],
Madri=[Alejandra Gomez(Madri)],
Sorocaba=[Marcos Cintra(Sorocaba), João Carlos(Sorocaba)],
Barra do Pirai=[Ana Beatriz(Barra do Pirai)]
}

2.0 AGRUPANDO OBJETOS COM A CLASSE “COLECTORS” DA API JAVA

COLLECTORS: classe da API do java que implementa vários métodos como
agrupamento de objetos. Com auxilio da API não é necessário varrer a lista d objetos.
Vamos apenas transformar em um fluxo (“steam”) que será lido pela classe “collectors”.
GROUPINGBY : agrupamento é feito por esse método
Code:
static <T, K> Collector<T,?,Map>> groupingBy(Function<? super T,? extends K>
classifier)
static <T, K, D, A, M extends Map<K, D>> Collector<T,?,M>
groupingBy(Function<? super T,? extends K> classifier, Supplier<M>
mapFactory, Collector<? super T,A,D> downstream)
static <T, K, A, D> Collector<T,?,Map> groupingBy(Function<? super T,?
extends K> classifier, Collector<? super T,A,D> downstream)

O agrupamento da classe “Collectors” uma função de classificação que

retorna um objeto classificador para cada objeto no fluxo de entrada. Formam
rótulos/chaves de cada grupo ou coleções formadas. Ele agrupa classes, lê os objetos do
fluxo de entrada, cria coleções de objetos correspondentes de cada classificador e da
como resultado um par ordenado(chave/coleção) que é armazenado em uma estrutura de
mapeamento “map”.

Code agrupamento com “groupBY”:

class Escola {
//Atributos
private String nome, CNPJ;
private Endereco endereco;
private List departamentos;
private List discentes;

//Métodos
public Escola ( String nome , String CNPJ) {
this.nome = nome;
this.CNPJ = CNPJ;
this.departamentos = new ArrayList ( );
this.discentes = new ArrayList<> ( );
}
public void criarDepartamento ( String nomeDepartamento ) {
departamentos.add ( new Departamento ( nomeDepartamento ) );
}
public void fecharDepartamento ( Departamento departamento ) {
departamentos.remove ( departamento );
}
public void matricularAluno ( Aluno novoAluno ) {
discentes.add ( novoAluno );
}
public void trancarMatriculaAluno ( Aluno aluno ) {
discentes.remove ( aluno );
}
public void agruparAlunos ( ) {
 Map < String , List < Aluno > > agrupamento =
discentes.stream().collect(Collectors.groupingBy(Aluno::recuperarNaturalidade
));
System.out.println ("Resultado do agrupamento por
naturalidade: ");
agrupamento.forEach (( String chave , List < Aluno > lista)
-> System.out.println (chave + " = " + lista ));
}
}

Saída:

Resultado do agrupamento por naturalidade:

São Paulo = [Marcio Gomes(São Paulo), César Augusto(São
Paulo), Castelo Branco(São Paulo)]
Rio de Janeiro = [Marco Antônio(Rio de Janeiro), Clara Silva(Rio
de Janeiro)]
Madri = [Alejandra Gomez(Madri)]
Sorocaba = [Marcos Cintra(Sorocaba), João Carlos(Sorocaba)]
Barra do Pirai = [Ana Beatriz(Barra do Pirai)]

3.0 COLEÇÕES

Coleções também chamadas de containers são objetos capazes de agrupar

múltiplos elementos em uma única unidade com finalidade de manipular e comunicar
dados agregados.
SET: abstração matemática de conjuntos. É usada para representar conjuntos e não
admite elementos duplicados.
LIST: implementa o conceito de listas e admite duplicidade. É uma coleção ordenada e
permite o acesso direto ao elemento armazenado assim como a posição onde armazena-
lo.
QUEUE: pode ser usado para criar uma fila(FIFO) mas também pode implementar uma
lista de propriedades onde os elementos são ordenados e consumidos segundo a
prioridade. Também, permite outras filas com outras ordens de ordenação.
DEQUE: estrutura de dados implementada é a DEQUE que pode ser usada como uma
fila(FIFO) ou pilha(LIFO). Pode inserir e tirar em ambas extremidades.
 MODULO 4 : AMBIENTE DE DESENVOLVIMENTO JAVA

JVM: plataforma padronizada que garante que o código java sempre poderá ser
executado quando existir uma jvm. Ele não executa as instruções java, mas sim os
bytecodes gerados pelo compilador java. O conjunto de bibliotecas e ambiente de
execução. A JRE é o elemento que gerencia a execução do código. Com a JRE pode se
exedutar um código java, mas não pode desenvolve-lo, para desenvolver precisamos do
JDK que engloba o JRE e mais um conjunto de ferramentas de desenvolvimento como:
Interpretador java (java)
Compilador java (javac)
Programa de arquivamento (jar)
Gerador de documentação (javadoc)

1.0 IDE
Ambiente integrado de desenvolvimento é um software que reúne
ferramentas de apoio e funcionalidades com o oj=objetivo de facilitar e acelerar o
desenvolvimento de um software. Engloba editar de código, interfaces e derpuraador.

2.0 ESTRUTURA E PRINCIPAIS CCOMENDOS DE UM PRGRAMA EM JAVA

Ponto de entrada não é obrigatório para compilar o programa, pode

compilar apenas classes, porem não será executado.