Apostila Java Básico Aula

Cálculo 01
Criando um Projeto...
File -> New -> Java Project.

Colocar o nome do projeto em Project Name... Marcar JRE -> JavaSE-1.7 e Create
separate folders for sources and class files -> Finish

[Link] 1
 Apostila Java Básico Aula

Cálculo 01
No projeto criado, expandir para a criação dos pacotes.

Na pasta sr , li ar o o otão direito -> New -> Package.

[Link] 2
 Apostila Java Básico Aula

Cálculo 01
E Sour e folder i di a o lo al o de o pa ote será riado e em Na e será
olo ado o o e do pa ote ( e tity ) -> Finish

Depois do pacote criado ele aparece em branco, vazio.

[Link] 3
 Apostila Java Básico Aula

Cálculo 01
Para riar a lasse, li ar o o otão direito o pa ote e tity -> New -> Class.

E Na e olo ar o o e da lasse Alu o -> Finish.

[Link] 4
 Apostila Java Básico Aula

Cálculo 01
Quando a classe é criada, o Eclipse apresenta dessa forma.

package entity;

public class Aluno {

private Integer codigo;

private String nome;
private String sexo;
private String disciplina;
private Double nota1;
private Double nota2;
private Double media = 0.;
private String situacao = "";
private Boolean ativo;

Os modificadores são os tipos de visibilidade que os atributos possuem. Eles

podem ser:
 Default (ou Friendly) – podem ser chamados por métodos do mesmo
pacote.
 Protected – podem ser chamados por métodos da prórpia classe ou
das subclasses.
 Private – só podem ser chamados por métodos da própria classe.
 Public – podem ser chamados por outros métodos de qualquer classe.

[Link] 5
 Apostila Java Básico Aula

Cálculo 01
Os tipos dos dados são, conforme esse exemplo:
 Integer
 String
 Double
 Boolean

Os atributos são as variáveis dessa classe. Todos os requisitos que o aluno

precisa ter.

O padrão de escrita é Camel Case, onde a primeira letra é minúscula e a

segunda palavra com letra maiúscula.

Por padrão todos os objetos possuem valores nulo. Então como o atributo
“media” será calculado ele precisa ser inicializado com o valor de 0. (zero). É
preciso colocar o ponto pois a tipagem desse atributo é Double.

O atributo “situacao” receberá uma palavra, então é iniciado com aspas

vazias.

O atributo “ativo” é do tipo Boolean, só receberá “true” ou “false”.

[Link] 6
 Apostila Java Básico Aula

Cálculo 01
public Aluno() {
// TODO Auto-generated constructor stub
}

Para criar o construtor vazio da classe é preciso apertar os botões: CTRL +

Espaço. Utilizando esse construtor as entradas de dados serão realizadas
através do set. É obrigatório a criação desse tipo de construtor.

Todos os comentários feitos em classe precisam ser precedidos de barra

(“//”).

public Aluno(Integer codigo, String nome, String sexo,

String disciplina, Double nota1, Double nota2, Boolean ativo) {
[Link] = codigo;
[Link] = nome;
[Link] = sexo;
[Link] = disciplina;
this.nota1 = nota1;
this.nota2 = nota2;
[Link] = ativo;
}

[Link] 7
 Apostila Java Básico Aula

Cálculo 01
Para criar o construtor cheio, no Menu -> Source -> Generate Constructor
using fields ou usar os botões ALT+ “S”. Marcar os campos que terão
entradas de dados. Os modificadores de acesso serão públicos.

No construtor cheio é onde serão passados as entradas de dados em

conjunto, todas juntas. Não colocamos a media, nem a situação pois ambos
serão calculados e não há necessidade de colocar seus valores.

Esse construtor é uma sobrecarga de métodos pois possui o mesmo nome

do construtor vazio, diferenciando pelo conteúdo dentro dos parênteses que
são os atributos tipados da classe. Os dados serão inseridos na ordem em
que estão relacionados. Dentro das chaves estão descritos os nomes dos
atributos sendo referidos pelo termo “this” que significa que o atributo é
desta classe.

@Override
public String toString() {
return "Aluno [codigo=" + codigo + ", nome=" + nome +
", sexo=" + sexo + ", disciplina=" + disciplina + ", nota1=" +
nota1 + ", nota2=" + nota2 + ", media=" + media + ", situacao="
+ situacao + ", ativo=" + ativo + "]";
}

[Link] 8
 Apostila Java Básico Aula

Cálculo 01

Para criar o toString, no Menu -> Source -> Generate toString. Selecionar
os campos para a saída das informações ou clicar em “Select All”.

[Link] 9
 Apostila Java Básico Aula

Cálculo 01
ToString é um método de saída, onde os dados são retornados de uma vez.

Para a criação do encapsulamento, ir no Menu, clicar em Source -> Generate

Getters and Setters ou ALT + “S”. Selecionar todos os atributos e deixars os
modificadores de acesso públicos.

[Link] 10
 Apostila Java Básico Aula

Cálculo 01
Métodos encapsuladores, onde “get” significa que é um método de saída e
“set” significa que é entrada. A palavra “void” significa que é um método de
ação.

public Integer getCodigo() {

return codigo;
}
public void setCodigo(Integer codigo) {
[Link] = codigo;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public String getSexo() {
return sexo;
}
public void setSexo(String sexo) {
[Link] = sexo;
}
public String getDisciplina() {
return disciplina;
}
public void setDisciplina(String disciplina) {
[Link] = disciplina;
}
public Double getNota1() {
return nota1;
}
public void setNota1(Double nota1) {
this.nota1 = nota1;
}
public Double getNota2() {
return nota2;
}
public void setNota2(Double nota2) {
this.nota2 = nota2;
}
public Double getMedia() {
return media;
}
public void setMedia(Double media) {
[Link] = media;

[Link] 11
 Apostila Java Básico Aula

Cálculo 01
}
public String getSituacao() {
return situacao;
}
public void setSituacao(String situacao) {
[Link] = situacao;
}
public Boolean getAtivo() {
return ativo;
}
public void setAtivo(Boolean ativo) {
[Link] = ativo;
}
}

Para criar um teste na classe chamamos o método “main”. Escrevemos a

palavra “main” e depois clicamos em CTRL + Espaço que o Eclipse se
encarrega de escrever o restante do método.

Chamamos a classe Aluno e criamos um objeto, chamado “a” e depois

chamamos o construtor cheio onde passamos os dados do aluno que será
criado. Todas as Strings precisam ser escritas entre aspas.

[Link] 12
 Apostila Java Básico Aula

Cálculo 01
Damos o comando de impressão que imprimirá os parâmetros passados
dentro dos parênteses que são: nome, sexo e disciplina. Utilizamos o sinal
de “+” para concatenar, colocar lado a lado, os parâmetros.

No outro comando de impressão imprimirá o objeto “a” que são os dados

passados no toString da classe.

public static void main(String[] args) {

Aluno a = new Aluno(100,"leo","m","java",7.,8.,true);

[Link]([Link]() + "," + [Link]() + "," +
[Link]());
[Link](a);
}

O atalho para o comando de impressão é: escrever a palavra “syso” e depois

clicamos em CTRL + Espaço + Enter.

[Link] 13
 Apostila Java Básico Aula

Cálculo 01
A classe completa ficará assim:

package entity;

public class Aluno {

private Integer codigo;

private String nome;
private String sexo;
private String disciplina;
private Double nota1;
private Double nota2;
private Double media = 0.;
private String situacao = "";
private Boolean ativo;

public Aluno() {
// TODO Auto-generated constructor stub
}

public Aluno(Integer codigo, String nome, String sexo,

String disciplina, Double nota1, Double nota2, Boolean ativo) {
super();
[Link] = codigo;
[Link] = nome;
[Link] = sexo;
[Link] = disciplina;
this.nota1 = nota1;
this.nota2 = nota2;
[Link] = ativo;
}

@Override
public String toString() {
return "Aluno [codigo=" + codigo + ", nome=" + nome +
", sexo=" + sexo + ", disciplina=" + disciplina + ", nota1=" +
nota1 + ", nota2=" + nota2 + ", media=" + media + ", situacao="
+ situacao + ", ativo=" + ativo + "]";
}

public Integer getCodigo() {

return codigo;
}
public void setCodigo(Integer codigo) {
[Link] = codigo;
}

[Link] 14
 Apostila Java Básico Aula

Cálculo 01
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public String getSexo() {
return sexo;
}
public void setSexo(String sexo) {
[Link] = sexo;
}
public String getDisciplina() {
return disciplina;
}
public void setDisciplina(String disciplina) {
[Link] = disciplina;
}
public Double getNota1() {
return nota1;
}
public void setNota1(Double nota1) {
this.nota1 = nota1;
}
public Double getNota2() {
return nota2;
}
public void setNota2(Double nota2) {
this.nota2 = nota2;
}
public Double getMedia() {
return media;
}
public void setMedia(Double media) {
[Link] = media;
}
public String getSituacao() {
return situacao;
}
public void setSituacao(String situacao) {
[Link] = situacao;
}
public Boolean getAtivo() {
return ativo;
}
public void setAtivo(Boolean ativo) {

[Link] 15
 Apostila Java Básico Aula

Cálculo 01
[Link] = ativo;
}

public static void main(String[] args) {

Aluno a = new Aluno(100,"leo","m","java",7.,8.,true);
[Link]([Link]() + "," + [Link]() +
"," + [Link]());
[Link](a);
}

Para testar o método main clique na classe Aluno -> Run as -> Java
Application ou CTRL + F11.

[Link] 16
 Apostila Java Básico Aula

Cálculo 01
No console do Eclipse aparece o resultado do teste da main:

Se por acaso o console não abrir automaticamente, clique no menu do

Eclipse -> Window -> Show view -> Console. Para expandi-lo
completamente dê dois cliques na aba do Console. Para minimiza-lo, dois
cliques novamente.

[Link] 17
 Apostila Java Básico Aula

Cálculo 01

Criar um pacote chamado “control” e nele uma classe chamada

“CalcularAluno”.

[Link] 18
 Apostila Java Básico Aula

Cálculo 01

package control;

import [Link];

public class CalcularAluno {

public void calcularMedia(Aluno a){

[Link]( (a.getNota1() + a.getNota2()) / 2 );
}
}

No método calcularMedia, informaremos como a média do aluno será

calculada. É um método de ação e por isso “void”.

Como “set” é entrada, em “[Link]” informaremos a fórmula do cálculo,

onde o objeto “a” de aluno somará “a.getNota1” e “a.getNota2” e depois
dividirá por 2.

public void gerarSituacao(Aluno a){

if ([Link]() < 7){
[Link]("Reprovado");
}else{

[Link] 19
 Apostila Java Básico Aula

Cálculo 01
[Link]("Aprovado");
}
}

No método gerarSituacao, vamos definir quais serão os critérios de

aprovação. No caso, se a média for menor que 7, o aluno será reporvado. Se
não, será aprovado.

public static void main(String[] args) {

Aluno a = new Aluno(10,"lu","f","java",5.,6.,true);
CalcularAluno ca = new CalcularAluno();
[Link](a);
[Link](a);
[Link](a);
}

No método main, vamos testar os outros métodos. Criamos o objeto da

classe Aluno, enchemos de informações esse objeto. Chamamos a classe
CalcularAluno, criamos um objeto para ela e damos espaço de memória. Em
seguida, através do objeto da classe CalcularAluno (“ca”), chamamos o
método calcularMedia, passando o objeto “a”, de Aluno, como parâmetro.
Depois através de “ca” chamamos o método de gerarSituacao. Então
pedimos para imprimir o resultado, que é o objeto “a” de Aluno. Imprimindo
assim o toString de Aluno.

A classe completa ficará assim:

package control;

import [Link];

public class CalcularAluno {

public void calcularMedia(Aluno a){

[Link]( (a.getNota1() + a.getNota2()) / 2 );
}

public void gerarSituacao(Aluno a){

if ([Link]() < 7){
[Link]("Reprovado");
}else{
[Link]("Aprovado");
}
}

[Link] 20
 Apostila Java Básico Aula

Cálculo 01

public static void main(String[] args) {

Aluno a = new Aluno(10,"lu","f","java",5.,6.,true);
CalcularAluno ca = new CalcularAluno();
[Link](a);
[Link](a);
[Link](a);
}

Para testar o método main clique na classe Aluno -> Run as -> Java
Application ou CTRL + F11 + Enter.

No console do Eclipse aparece o resultado do teste da main:

[Link] 21
 Apostila Java Básico Aula

Herança 02
Criando um Projeto...
File -> New -> Java Project.

Colocar o nome do projeto em Project Name...

Marcar JRE -> JavaSE-1.7 e Create separate folders for sources and class files ->
Finish.

No projeto criado, expandir para a criação dos pacotes.

Na pasta sr , li ar o o otão direito -> New -> Package.

E Sour e folder i di a o lo al o de o pa ote será riado e em Na e será

olo ado o o e do pa ote ( e tity ) -> Finish.

Depois do pacote criado ele aparece em branco, vazio.

Para riar a lasse, li ar o o otão direito o pa ote e tity -> New -> Class.

E Na e olo ar o o e da lasse -> Finish.

package entity;

public class Pessoa{

private String nome;

private String email;
private String sexo;

public Pessoa() {
}

public Pessoa(String nome, String email, String sexo) {

super();
[Link] = nome;
[Link] = email;
[Link] = sexo;
}

[Link] 1
 Apostila Java Básico Aula

Herança 02
@Override
public String toString() {
return "Pessoa [nome=" + nome + ", email=" + email + ",
sexo=" + sexo + "]";
}

public String getNome() {

return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
[Link] = email;
}
public String getSexo() {
return sexo;
}
public void setSexo(String sexo) {
[Link] = sexo;
}
}

[Link] 2
 Apostila Java Básico Aula

Herança 02

Essa classe foi criada com objetivo de ser herdada por uma outra classe. No
caso a classe Cliente vai herdar da classe Pessoa.

Criar a classe Cliente no pacote entity. A palavra “extends” quer dizer que
uma classe vai herdar os dados de outra classe. Existe um vínculo usado
através do verbo “ser”, onde, no nosso exemplo, Cliente é uma Pessoa.
Cliente além de possuir os dados específicos dele ainda herdará os dados
constantes na classe Pessoa.

package entity;

import [Link];

public class Cliente extends Pessoa{

private Integer codigo;

private Date dataCadastro;

[Link] 3
 Apostila Java Básico Aula

Herança 02
}

A classe Cliente possui dois atributos, “código” e “dataCadastro”. Será feito o

construtor vazio e o construtor cheio que herdará os atributos de Pessoa, da
seguinte forma:

No menu do Eclipse, selecionar Source -> Generate Constructor using Fields.

Em select super constructor to invoke, selecionar a classe Pessoa trazendo
os atributos dela.

public Cliente() {
// TODO Auto-generated constructor stub
}

public Cliente(String nome, String email, String sexo,

Integer codigo, Date dataCadastro) {
super(nome, email, sexo);
[Link] = codigo;
[Link] = dataCadastro;
}

[Link] 4
 Apostila Java Básico Aula

Herança 02
O construtor cheio agora possui os atributos de Pessoa e de Cliente. Quando
for criado o objeto de Cliente será passado os dados de “nome”, “email”,
“sexo”, “código”, “dataCadastro”. Por uma questão de facilitar o
entendimento vamos reorganizar os atributos. Colocando em uma outra
ordem.

public Cliente(Integer codigo, String nome, String email,

String sexo, Date dataCadastro) {
super(nome, email, sexo);
[Link] = codigo;
[Link] = dataCadastro;
}

@Override
public String toString() {
return "Cliente [codigo=" + codigo + ", dataCadastro="
+ new SimpleDateFormat("dd/MM/yyyy").format(dataCadastro) + ",
Nome=" + getNome() + ", Email=" + getEmail() + ", Sexo=" +
getSexo() + "]";
}

O toString é a saída, como os dados serão impressos. A data foi formatada

para aparecer no padrão brasileiro e os dados da super Classe também
serão impressos.

public String toStringSuper(){

return [Link]();
}

Nesse outro método toString imprime somente os dados da superClasse. E

depois fazer os getters e setters na classe Cliente.

public Integer getCodigo() {

return codigo;
}
public void setCodigo(Integer codigo) {
[Link] = codigo;
}
public Date getDataCadastro() {
return dataCadastro;

[Link] 5
 Apostila Java Básico Aula

Herança 02
}
public void setDataCadastro(Date dataCadastro) {
[Link] = dataCadastro;
}

Vamos testar a classe Cliente fazendo o método main.

public static void main(String[] args) {

Cliente c = new Cliente(10,"jose", "jose@[Link]",
"m",new Date("06/10/2015"));
[Link](c);
}
Chamamos a classe Cliente, criamos o objeto “c” de Cliente e enchemos o
construtor com os dados do Cliente. Na data passamos o padrão do Java,
que é mês/dia/ano. Depois pedimos para imprimir no console o objeto “c”.
Clique na classe Cliente -> Run as -> Java Application ou CTRL + F11.

No console do Eclipse aparece o resultado do teste da main.

[Link] 6
 Apostila Java Básico Aula

Relacionamento 03
Classe Funcionario tem Endereco

Criar um projeto -> Aula03

Criar uma classe Funcionario contendo 2 atributos (código, nome).

package entity;

public class Funcionario {

private Integer codigo;

private String nome;
}

Criar uma classe Endereco contendo os seguintes atributos: código, bairro,

cidade, os construtores, toString e getters e setters.

package entity;

public class Endereco {

private Integer codigo;

private String bairro;
private String cidade;

public Endereco() {
}

public Endereco(Integer codigo, String bairro, String

cidade) {
super();
[Link] = codigo;
[Link] = bairro;
[Link] = cidade;
}

@Override

[Link] 1
 Apostila Java Básico Aula

Relacionamento 03
public String toString() {
return "Endereco [codigo=" + codigo + ", bairro=" +
bairro + ", cidade=" + cidade + "]";
}

public Integer getCodigo() {

return codigo;
}
public void setCodigo(Integer codigo) {
[Link] = codigo;
}
public String getBairro() {
return bairro;
}
public void setBairro(String bairro) {
[Link] = bairro;
}
public String getCidade() {
return cidade;
}
public void setCidade(String cidade) {
[Link] = cidade;
}
}

Voltando na classe Funcionario, criar o relacionamento do funcionário com

endereço. Acrescentamos o atributo endereço na classe. Ficando dessa
forma:

[Link] 2
 Apostila Java Básico Aula

Relacionamento 03
package entity;

public class Funcionario {

private Integer codigo;

private String nome;

private Endereco endereco;

A classe Endereco virou um atributo da classe Funcionario. Dessa forma

indicamos que Funcionario tem um Endereco. Agora criar os outros métodos
restantes (construtores, toString e getters e setters).

public Funcionario() {
// TODO Auto-generated constructor stub
}

public Funcionario(Integer codigo, String nome, Endereco

endereco) {
super();
[Link] = codigo;
[Link] = nome;

[Link] 3
 Apostila Java Básico Aula

Relacionamento 03
[Link] = endereco;
}

Criar um construtor cheio completo, com todos os atributos, incluindo

endereço e criar um outro construtor cheio sem o atributo endereço.

public Funcionario(Integer codigo, String nome) {

super();
[Link] = codigo;
[Link] = nome;
}

O toString será completo, contendo o endereço, pois é a saída. Imprimirá

funcionário contendo endereço.

@Override
public String toString() {
return "Funcionario [codigo=" + codigo + ", nome=" +
nome + ", endereco=" + endereco + "]";
}

E os getters e setters de todos os atributos.

public Integer getCodigo() {

return codigo;
}
public void setCodigo(Integer codigo) {
[Link] = codigo;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public Endereco getEndereco() {
return endereco;
}
public void setEndereco(Endereco endereco) {

[Link] 4
 Apostila Java Básico Aula

Relacionamento 03
[Link] = endereco;
}

A classe completa ficará da seguinte forma:

package entity;

public class Funcionario {

private Integer codigo;

private String nome;

private Endereco endereco;

public Funcionario() {
// TODO Auto-generated constructor stub
}

public Funcionario(Integer codigo, String nome) {

super();
[Link] = codigo;
[Link] = nome;
}

public Funcionario(Integer codigo, String nome, Endereco

endereco) {
super();
[Link] = codigo;
[Link] = nome;
[Link] = endereco;
}

@Override
public String toString() {
return "Funcionario [codigo=" + codigo + ", nome=" +
nome + ", endereco=" + endereco + "]";
}

public Integer getCodigo() {

return codigo;
}
public void setCodigo(Integer codigo) {

[Link] 5
 Apostila Java Básico Aula

Relacionamento 03
[Link] = codigo;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public Endereco getEndereco() {
return endereco;
}
public void setEndereco(Endereco endereco) {
[Link] = endereco;
}
}

Para testar a classe Funcionario fazer um método main.

public static void main(String[] args) {

Funcionario f1 = new Funcionario(10,"Luciana",new
Endereco(10,"Ipanema","Rio de Janeiro"));
Funcionario f2 = new Funcionario();
[Link](11);
[Link]("Carolina");
[Link](new Endereco(11,"Tijuca","Rio de
Janeiro"));
[Link](f1);
[Link]([Link]() + "," + [Link]() );
[Link]([Link]().getBairro());
}
Criamos o objeto do funcionário “f1” e passamos os dados através do
construtor cheio. Depois criamos o funcionário “f2” e usamos o construtor
vazio, passando os dados através do “set” de cada atributo. Pedimos a
impressão do “f1” completa, através do toString e “f2” imprimiremos
somente o que foi pedido (código, nome) e (bairro). A impressão no console
fica da seguinte forma:

[Link] 6
Apostila Java Básico Aula

Relacionamento 03

[Link] 7
 Apostila Java Básico Aula

Relacionamento 04
Classe Correntista FormataData usando Calendar

Criar um projeto -> Aula04

Criar um pacote chamado entity.
Criar uma classe Correntista contendo os atributos (código, nome, saldo, email,
dataCadastro).

package entity;

import [Link];
import [Link];

public class Correntista {

private Integer codigo;
private String nome;
private Double saldo=0.;
private String email;
private Calendar dataCadastro;

Na hora de tipar a dataCadastro usar a importação de Calendar. Para

importar clicar em CTRL + SHIFT + O.

public Correntista() {
}

public Correntista(Integer codigo, String nome, Double

saldo, String email, Calendar dataCadastro) {
super();
[Link] = codigo;
[Link] = nome;
[Link] = saldo;
[Link] = email;
[Link] = dataCadastro;
}

@Override
public String toString() {
return "Correntista [codigo=" + codigo + ", nome=" +
nome + ", saldo=" + saldo + ", email=" + email + ",

[Link] 1
 Apostila Java Básico Aula

Relacionamento 04
dataCadastro=" + new SimpleDateFormat("dd/MM/yyyy").format
([Link]()) + "]";
}

No toString formatará como será apresentada a saída utilizando o

SimpleDateFormat, colocando na ordem brasileira de data (“dd/MM/yyyy”).
A formatação do mês é preciso que seja com letras maiúsculas pois senão
será interprestado como minutos (hora).

public Integer getCodigo() {

return codigo;
}
public void setCodigo(Integer codigo) {
[Link] = codigo;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public Double getSaldo() {
return saldo;
}
public void setSaldo(Double saldo) {
[Link] = saldo;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
[Link] = email;
}
public Calendar getDataCadastro() {
return dataCadastro;
}
public void setDataCadastro(Calendar dataCadastro) {
[Link] = dataCadastro;
}

No teste da main, criar o objeto de Correntista e setar os dados dele. O

Calendar começa contando os meses a partir de 0 (zero). Ex: jan=0, fev=1.
Chamar a classe Calendar e depois setar a data. Pedir a impressão no
console.

[Link] 2
 Apostila Java Básico Aula

Relacionamento 04

public static void main(String[] args) {

Correntista c = new Correntista();

[Link](1001);
[Link]("pedro");
[Link]("pedro@[Link]");
[Link](7000.);
Calendar cal = [Link]();
[Link](2015,05,10);
[Link](cal);
[Link](c);

Criar um objeto x para a classe Calendar e depois dar espaço de memória.

Setar a nova data. Criar um Correntista novo e passar os dados e pedir as
impressões.

Calendar x = [Link]();
[Link](2015, 01 ,10);
Correntista c2 = new
Correntista(10,"lu",5000.,"lu@[Link]", x );
[Link](c2);

[Link]("Ano :" +
[Link]().get([Link]));
[Link]("Mes :" + (1 +
[Link]().get([Link])) );
[Link]("Dia :" +
[Link]().get(Calendar.DAY_OF_MONTH));
}
}

[Link] 3
Apostila Java Básico Aula

Relacionamento 04

[Link] 4
 Apostila Java Básico Aula

Cálculo Produto 05
Classe Produto e Calculo de Produto

Criar um projeto -> Aula05

Criar um pacote chamado entity.
Criar uma classe completa de Produto contendo os atributos (código, nome,
preço, quantidade, tipo, ativo, desconto), os contrutores vazio e cheio, toString, e
getters e setters.

package entity;

public class Produto {

private Integer codigo;

private String nome;
private Double preco;
private Integer quantidade;
private String tipo;
private Boolean ativo;
private transient Double desconto=0.;

O atributo “ativo” é do tipo Boolean pois ele estamos informando se o

produto está ativo ou não, representa a condição dele. O atributo “desconto”
é tipado transient pois não será gravado em banco, ele será calculado e
dessa forma, precisa ser inciado com o valor 0.

public Produto() {

public Produto(Integer codigo, String nome, Double preco,

Integer quantidade, String tipo, Boolean ativo) {
super();
[Link] = codigo;
[Link] = nome;
[Link] = preco;
[Link] = quantidade;
[Link] = tipo;
[Link] = ativo;
}

[Link] 1
 Apostila Java Básico Aula

Cálculo Produto 05

@Override
public String toString() {
return "Produto [codigo=" + codigo + ", nome=" + nome +
", preco=" + preco + ", quantidade=" + quantidade + ", tipo=" +
tipo + ", ativo=" + ativo + "]";
}

public Integer getCodigo() {

return codigo;
}
public void setCodigo(Integer codigo) {
[Link] = codigo;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public Double getPreco() {
return preco;
}
public void setPreco(Double preco) {
[Link] = preco;
}
public Integer getQuantidade() {
return quantidade;
}
public void setQuantidade(Integer quantidade) {
[Link] = quantidade;
}
public String getTipo() {
return tipo;
}
public void setTipo(String tipo) {
[Link] = tipo;
}
public Boolean isAtivo() {
return ativo;
}
public void setAtivo(Boolean ativo) {
[Link] = ativo;
}

[Link] 2
 Apostila Java Básico Aula

Cálculo Produto 05
public Boolean getAtivo() {
return ativo;
}
public Double getDesconto() {
return desconto;
}
public void setDesconto(Double desconto) {
[Link] = desconto;
}
}

Criar um pacote chamado control, depois uma classe chamada

CalcularProduto para fazermos algum tipo de cálculo relacionado a classe
Produto.

package control;

import [Link];

public class CalcularProduto {

public static void calcularDescontoProduto(Produto p) {

if ([Link]().equalsIgnoreCase("celular")) {
[Link](([Link]() * 10) / 100);
} else if ([Link]().equalsIgnoreCase("computador"))
{
[Link](([Link]() * 20) / 100);
} else {
[Link](0.);
}
}

Criamos um método “static” chamado calcularDescontoProduto, como o

nome já diz, para calcular o desconto de um produto. Um método estático
pode ser chamado direto pelo nome, sem precisar chamar a classe primeiro
para depois chamá-lo.

Criamos uma condição, se o produto for do tipo celular, o método

“equalsIgnoreCase” é utilizado para qualquer que seja o tipo da letra
(maiúscula ou minúscula), será reconhecido pelo sistema e efetuará o
cálculo do desconto.

No setDesconto passar a formula do cálculo do desconto dessa condição.

[Link] 3
 Apostila Java Básico Aula

Cálculo Produto 05
A outra condição é se o produto for do tipo computador, será efetuado um
outro tipo de cálculo.

E se não for nenhuma das duas condições, não haverá desconto.

public static void main(String[] args) {

Produto p = new
Produto(10,"arroz",4.,10,"alimento",true);
[Link](p);

[Link]("Produto: " + [Link]());

[Link]( "Total :" +
( ([Link]() - [Link]()) *
[Link]()));

Produto p2 = new
Produto(12,"Hiphone",2000.,1,"celular",true);
[Link](p2);
[Link]([Link]());
[Link]("Total :" +
( ([Link]() - [Link]()) *
[Link]() ) );
}
}

No teste main, criamos um objeto de produto com os dados. Chamamos a

classe de calculo e o método para ser calculado se houver algum tipo de
desconto. Pedimos para imprimir no console o nome do produto e o preço
final (já com desconto).

Se o método calcularDescontoProduto não fosse estático, o main teria que

ser escrito de uma outra forma. Chamaríamos a classe, criaríamos um
objeto pra ela. Depois abriríamos espaço de memória no método para
trabalharmos com ele.

public static void main(String[] args) {

Produto p = new
Produto(10,"arroz",4.,10,"alimento",true);
CalcularProduto cp = new CalcularProduto();

[Link] 4
 Apostila Java Básico Aula

Cálculo Produto 05
[Link](p);
}

[Link] 5
 Apostila Java Básico Aula

Joption Pane, Formatação 06

Classe Funcionário

Criar um projeto -> Aula06

Criar um pacote chamado entity.
Criar uma classe completa de Funcionario contendo os atributos (idFuncionario,
nome, salarioBruto, salarioLiquido, sexo, descontos, bonus), os contrutores vazio
e cheio, toString, e getters e setters.

package entity;

import [Link];
import [Link];
import [Link];

Vamos implementar a interface Comparable para fazer a ordenação e

comparação. A interface Comparable traz o método compareTo que é
responsável pela ordenação.

Interface é uma classe que padroniza a forma de trabalhar.

public class Funcionario implements Comparable<Funcionario>{

private Integer idFuncionario;

private String nome;
private Double salarioBruto;
private transient Double salarioLiquido;
private String sexo;
private Double descontos;
private Double bonus;

Criaremos um bloco anônimo para inicializar o atributo salarioLiquido com o

valor 0 (zero). Esse tipo de bloco é iniciado antes do construtor. Estamos
dizendo que quando o construtor rodar o salarioLiquido zerá 0 (zero) e assim
poderá ser calculado sem a possibilidade de erro.

{
salarioLiquido = 0.;

[Link] 1
 Apostila Java Básico Aula

Joption Pane, Formatação 06

}

public Funcionario() {

public Funcionario(Integer idFuncionario, String nome,

Double salarioBruto, String sexo, Double descontos, Double
bonus) {
super();
[Link] = idFuncionario;
[Link] = nome;
[Link] = salarioBruto;
[Link] = sexo;
[Link] = descontos;
[Link] = bonus;
}

@Override
public String toString() {
return "Funcionario [idFuncionario=" + idFuncionario +
", nome=" + nome + ", salarioBruto=" + salarioBruto + ",
salarioLiquido=" + salarioLiquido + ", sexo=" + sexo + ",
descontos=" + descontos + ", bonus=" + bonus + "]";
}

public Integer getIdFuncionario() {

return idFuncionario;
}
public void setIdFuncionario(Integer idFuncionario) {
[Link] = idFuncionario;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public Double getSalarioBruto() {
return salarioBruto;
}
public void setSalarioBruto(Double salarioBruto) {

[Link] 2
 Apostila Java Básico Aula

Joption Pane, Formatação 06

[Link] = salarioBruto;
}
public Double getSalarioLiquido() {
return salarioLiquido;
}
public void setSalarioLiquido(Double salarioLiquido) {
[Link] = salarioLiquido;
}
public String getSexo() {
return sexo;
}
public void setSexo(String sexo) {
[Link] = sexo;
}
public Double getDescontos() {
return descontos;
}
public void setDescontos(Double descontos) {
[Link] = descontos;
}
public Double getBonus() {
return bonus;
}
public void setBonus(Double bonus) {
[Link] = bonus;
}

Para criar o método equals, pode-se clicar em CTRL + Espaço.

[Link] 3
 Apostila Java Básico Aula

Joption Pane, Formatação 06

No método equals, é sobrescrito e feito a igualdade de objetos, isto é, se o

id de um funcionario é igual ao id do outro, tendo como resultado “true” ou
“false” pois é um método booleano. Passo a classe Funcionario e crio o
objeto “f” e depois faço um Casting convertendo a Classe em objeto “o”.

@Override
public boolean equals(Object o){
Funcionario f = (Funcionario) o;
return [Link]([Link]());
}

Para criar o método compareTo, ir no menu do Eclipse -> Source ->

Override/Implents Methods -> Comparable

[Link] 4
Apostila Java Básico Aula

Joption Pane, Formatação 06

[Link] 5
 Apostila Java Básico Aula

Joption Pane, Formatação 06

No método compareTo, quem vem da interface, sobrescever pois estamos
comparando se o id desse Funcionário (através do [Link]) é igual
ao id de um outro Funcionario([Link]) para ser ordenado de
forma ascendente.

@Override
public int compareTo(Funcionario f) {
return
[Link]([Link]());
}

No main, criamos 3 funcionarios com ids aleatórios para serem ordenados.

Chamamos a interface List e criamos o objeto lista. Demos espaço de
memória para List através do ArrayList. Adicionamos os funcionários (f1, f2
e f3) na lista e depois pedimos para a lista ser ordenada com a Interface
Collections e o método sort. Então pedimos para imprimir essa lista
ordenada, um funcionário do lado do outro. “\n” é para pular linha.

public static void main(String[] args) {

Funcionario f1 = new
Funcionario(20,"jose",1000.,"m",300., 0.);
Funcionario f2 = new
Funcionario(10,"marcelo",2500.,"m",500.,0.);
Funcionario f3 = new
Funcionario(5,"lu",7000.,"f",100.,0.);

List<Funcionario> lista = new ArrayList<Funcionario>();

[Link](f1);
[Link](f2);
[Link](f3);

[Link](lista);
[Link]("Lista Ordenada :" + lista);
[Link]("\n");

Com o for, criamos um loop que enquanto houver funcionário ele imprimirá
a lista também já ordenada. Um outro for foi criado para demonstrar como
também pode ser trazidos as informações, utilizando a quantidade de
valores da lista.

[Link] 6
 Apostila Java Básico Aula

Joption Pane, Formatação 06

for(Funcionario x : lista){
[Link]("foreach :" + x);
}
[Link]("\n");

for (int i=0 ; i < [Link]() ; i++){

[Link]("indice :" + i + ", " +
[Link](i));
}
}
}

No console a impressão fica assim:

Lista Ordenada :[Funcionario [idFuncionario=5, nome=lu,

salarioBruto=7000.0, salarioLiquido=0.0, sexo=f,
descontos=100.0, bonus=0.0], Funcionario [idFuncionario=10,
nome=marcelo, salarioBruto=2500.0, salarioLiquido=0.0, sexo=m,
descontos=500.0, bonus=0.0], Funcionario [idFuncionario=20,
nome=jose, salarioBruto=1000.0, salarioLiquido=0.0, sexo=m,
descontos=300.0, bonus=0.0]]

foreach :Funcionario [idFuncionario=5, nome=lu,

salarioBruto=7000.0, salarioLiquido=0.0, sexo=f,
descontos=100.0, bonus=0.0]
foreach :Funcionario [idFuncionario=10, nome=marcelo,
salarioBruto=2500.0, salarioLiquido=0.0, sexo=m,
descontos=500.0, bonus=0.0]
foreach :Funcionario [idFuncionario=20, nome=jose,
salarioBruto=1000.0, salarioLiquido=0.0, sexo=m,
descontos=300.0, bonus=0.0]

indice :0, Funcionario [idFuncionario=5, nome=lu,

salarioBruto=7000.0, salarioLiquido=0.0, sexo=f,
descontos=100.0, bonus=0.0]
indice :1, Funcionario [idFuncionario=10, nome=marcelo,
salarioBruto=2500.0, salarioLiquido=0.0, sexo=m,
descontos=500.0, bonus=0.0]

[Link] 7
 Apostila Java Básico Aula

Joption Pane, Formatação 06

indice :2, Funcionario [idFuncionario=20, nome=jose,
salarioBruto=1000.0, salarioLiquido=0.0, sexo=m,
descontos=300.0, bonus=0.0]

Criar um pacote control e uma classe CalculoFuncionario, onde será

calculado o salário líquido do funcionário. Será criado o método
calcularSalario e será passado o funcionário como parâmetro. Depois o
salário liquido será setado com a fórmula do cálculo.

package control;

import [Link];

[Link] 8
 Apostila Java Básico Aula

Joption Pane, Formatação 06

public class CalculoFuncionario {

public static void calcularSalario(Funcionario f){

[Link]([Link]() -
[Link]() + [Link]());
}
}

Vamos criar um outro pacote chamado view onde colocaremos as classes de

visão. Onde é feito a interação com o usuário do sistema. Criar uma classe
chamada InputFuncionario e métodos para ler o código, o nome, sexo,
desconto, bônus e salário. No método lerCodigo, a entrada é em String e
convertida em Integer, assim como os métodos de lerDesconto e lerBonus
serão convertido em Double.

package view;

import [Link];
import [Link];

public class InputFuncionario {

public Integer lerCodigo(){

Integer codigo=0;
try{
codigo = new
Integer([Link]("Digite o Codigo", ""));
return codigo;
}catch(Exception ex){
[Link](null, "Error :" +
[Link]());
return lerCodigo(); }
}

Foi criado um método chamado lerCodigo que retorno um numero inteiro.

Criamos uma variável local iniciada com o valor de 0 (zero). Dentro do try
colocamos a variável (código) e chamamos a interface JOptionPane para
abrir uma caixa de diálogo contendo a instrução na tela para o usuário
digitar os dados e um espaço para a entrada desses dados. Se for digitado
corretamente, retorna o código. Se der erro, cai no catch e abre uma caixa
de diálogo contendo o a mensagem de erro e retorna para o método
novamente até o código ser digitado de forma correta.

[Link] 9
 Apostila Java Básico Aula

Joption Pane, Formatação 06

public String lerNome(){

String nome = [Link]("Entre Com o
Nome :","");
return nome;
}

public String lerSexo(){

String sexo = [Link]("Entre Com o
Sexo :","");
return sexo;
}

Nos outros métodos lerNome e lerSexo, foram criados as respectivas

variáveis e a as caixas de diálogo sem a necessidade de try e catch.

public Double lerDesconto(){

Double desconto=0.;
try{
desconto = new Double([Link]("Entre
Com o Desconto :",""));
return desconto;
}catch(Exception ex){
[Link](null, "Error :" +
[Link]());
return lerDesconto();
}
}

public Double lerBonus(){

Double bonus=0.;
try{
bonus = new Double([Link]("Entre Com
o Bonus :",""));
return bonus;
}catch(Exception ex){
[Link](null, "Error :" +
[Link]());
return lerBonus(); //recursividade
}
}

[Link] 10
 Apostila Java Básico Aula

Joption Pane, Formatação 06

public Double lerSalario(){

Double salario=0.;
try{
salario = new Double([Link]("Entre
Com o Salario :",""));
return salario;
}catch(Exception ex){
[Link](null, "Error :" +
[Link]());
return lerSalario();
}
}

public static void main(String[] args) {

try{
Funcionario f = new Funcionario();
InputFuncionario ifu = new InputFuncionario();
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link](f);
}catch(Exception ex){
[Link]([Link]());
}
}
}

Ao rodar o main, abre a caixa de diálogo chamada pelo método JOptionPane

para ser inseridos os dados.

[Link] 11
 Apostila Java Básico Aula

Joption Pane, Formatação 06

Se na caixa de diálogo, for escrito letra no campo onde era esperado um

numero para o código, o sistema gerará um erro, apresentará na tela e
voltará para a caixa até o ser digitado o tipo de dados esperado.

[Link] 12
Apostila Java Básico Aula

Joption Pane, Formatação 06

[Link] 13
Apostila Java Básico Aula

Joption Pane, Formatação 06

[Link] 14
 Apostila Java Básico Aula

Joption Pane, Formatação 06

No console, imprime os dados inseridos na caixa de diálogo.

[Link] 15
 Apostila Java Básico Aula

Joption Pane, Formatação 06

Criar uma classe chamada FormatOutput para formatação da saída dos
dados.

package view;

import [Link];
import [Link];
import [Link];

public class FormatOuput {

Chamar a classe abstrata NumberFormat responsável pela formação de

números, criar um objeto para ela. Depois criar um método para formatar a
saída dos valores.

NumberFormat nf;

Dentro do método, chamar o objeto da classe de formatação e passar a

localização para que os valores sejam impressos de acordo com o padrão da
região. No caso do Brasil, usando R$, ponto entre as 3 casas de milhar e
vírgula nas duas casas decimais. Formatar também o máximo e o mínimo de
casas decimais.

public FormatOuput() {
nf = [Link](new Locale("pt","BR"));
[Link](2);
[Link](2);
}

Vamos criar métodos para formatar cada uma das saídas dos valores.

public String getSalarioBrutoFormatado(Funcionario f){

return [Link]([Link]());
}
public String getSalarioLiquidoFormatado(Funcionario f){
return [Link]([Link]());
}
public String getBonusFormatado(Funcionario f){

[Link] 16
 Apostila Java Básico Aula

Joption Pane, Formatação 06

return [Link]([Link]());
}
public String getDescontoFormatado(Funcionario f){
return [Link]([Link]());
}

No teste da main, chamar a classe Funcionario, criar o objeto e dar espaço

para memória. Fazer a mesma coisa nas classes: InputFuncionario e
FormatOutput. Chama o objeto de funcionário, seta os dados de cada
atributo e passa o objeto da saída da formatação com os métodos para
inserir as informações.

public static void main(String[] args) {

try{
Funcionario f = new Funcionario();
InputFuncionario ifu = new InputFuncionario();
FormatOuput fo = new FormatOuput();

[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
Imprime as saídas com nome e o salário bruto já formatado.

[Link]("Nome :" + [Link]());

[Link]("Salario Bruto:" +
[Link](f));
}catch(Exception ex){
[Link]([Link]());
}
}
}

[Link] 17
Apostila Java Básico Aula

Joption Pane, Formatação 06

[Link] 18
Apostila Java Básico Aula

Joption Pane, Formatação 06

[Link] 19
Apostila Java Básico Aula

Joption Pane, Formatação 06

[Link] 20
 Apostila Java Básico Aula

Joption Pane, Formatação 06

Criar uma classe chamada OutputText para exibir a saída de texto. Criar um
método printFuncionario e passar os parâmetros da classe Funcionario e da
classe FormatOutput. Cria a variável linha do tipo String passando os dados.
Chamar a classe de JOptionPane, habilitar a janela de diálogo e o método
estático showMessageDialog para apresentar a impressão dos dados
digitados.

package view;

import [Link];
import [Link];
import [Link];

public class OutputText {

public static void printFuncionario(Funcionario f,

FormatOuput fo){

String linha = "Codigo:" + [Link]() + "\n" +

"Nome:" + [Link]() + "\n" +
"Sexo:" + [Link]() + "\n" +
"Salario Bruto:" + [Link](f) + "\n " +
"Bonus:" + [Link](f) + "\n " +
"Desconto:" + [Link](f) + "\n " +

[Link] 21
 Apostila Java Básico Aula

Joption Pane, Formatação 06

"Salario Liquido:" + [Link](f);

[Link](null, linha);
}

No teste main, usar os blocos try e catch, em try, chamar as classes de

Funcionario, InputFuncionario e FormatOutput com seus espaços de
memória. Setar os atributos de funcionário passando os métodos de
inserção de dados. Pedir para calcular o salário do funcionário passando a
classe CalculoFucionario e o método calcularSalario. Chamar a classe
OutputText para trazer a formatação da saída através do método
printFuncionario e passando como parâmetro os objetos “f” e “fo”.

public static void main(String[] args) {

try{
Funcionario f = new Funcionario();
InputFuncionario ifu = new InputFuncionario();
FormatOuput fo = new FormatOuput();
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link](f);
[Link](f, fo);
}catch(Exception ex){
[Link]([Link]());
}
}
}

Quando executada a classe, abrirá as caixas de diálogo para inserção dos

dados e no fim, a impressão na janela dos dados informados.

[Link] 22
Apostila Java Básico Aula

Joption Pane, Formatação 06

[Link] 23
Apostila Java Básico Aula

Joption Pane, Formatação 06

[Link] 24
Apostila Java Básico Aula

Joption Pane, Formatação 06

[Link] 25
 Apostila Java Básico Aula

Joption Pane, Formatação 06

Quando for informado o último dado será apresentada a caixa com a
impressão de todas as informações.

[Link] 26
 Apostila Java Básico Aula

Herança 07
Classe Funcionário, Estagiário e Programador

Criar um projeto -> Aula07

Criar um pacote chamado entity.
Criar uma classe abstrata de Funcionario contendo os atributos (código, nome,
sexo e salario), os contrutores vazio e cheio, toString, e getters e setters.

package entity;

public abstract class Funcionario {

private Integer codigo;

private String nome;
private String sexo;
private Double salario;

public Funcionario() {

public Funcionario(Integer codigo, String nome, String sexo,

Double salario) {
super();
[Link] = codigo;
[Link] = nome;
[Link] = sexo;
[Link] = salario;
}

@Override
public String toString() {
return "Funcionario [codigo=" + codigo + ", nome=" +
nome + ", sexo=" + sexo + ", salario=" + salario + "]";
}

public Integer getCodigo() {

return codigo;
}
public void setCodigo(Integer codigo) {
[Link] = codigo;

1
 Apostila Java Básico Aula

Herança 07
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public String getSexo() {
return sexo;
}
public void setSexo(String sexo) {
[Link] = sexo;
}
public Double getSalario() {
return salario;
}
public void setSalario(Double salario) {
[Link] = salario;
}

Criar também o método abstrato getBonus que será implementado na classe

de herança e o getMessage que retornará uma mensage específica.

public abstract Double getBonus();

public String getMessage(){

return "Classe Abstrata";
}
}

Criar a classe Estagiario que herdará através da palavra “extends” da classe

Funcionario, implementará o método abstrato “getBonus” que estava na
classe Funcionario clicando na lâmpada ao lado do nome da classe. Nessa
classe, o Estagiário terá um bônus de 200, conforme retorno.

2
 Apostila Java Básico Aula

Herança 07

Será exibida uma mensagem pedindo para o método ser implementado... Só

clicar!

3
 Apostila Java Básico Aula

Herança 07
package entity;

public class Estagiario extends Funcionario {

Haverá uma sobrescrita no método getBonus.

@Override
public Double getBonus() {
return 200.;
}

public String getMessage(){

return "Sub Classe Estagiario";
}
}

Criar uma outra classe chamada Programador. Fazer o mesmo com essa
classe, herdar da classe Funcionario e implementar o método, colocando um
corpo, o retorno no “getBonus” de 1500. Isto é, o Programador terá um
bônus de 1500.

package entity;

public class Programador extends Funcionario {

@Override
public Double getBonus() {
return 1500.;
}

public String getMessage(){

return "Sub Classe Programador";
}
}

4
 Apostila Java Básico Aula

Herança 07

Criar uma classe chamada MainAbstrata para testar. Criar um objeto para
Funcionario e sobrescrever o método getBonus passando novo valor para
ele. Onde Funcionário terá um bônus de 100. Passar através so set: o nome
e o salário. Na impressão pedir para imprimir o nome desse funcionário e o
resultado da soma do salário com o bônus.

Criamos novo Funcionário e instaciamos o Estagiario, passamos seus dados

(código, nome e salário)

package main;

import [Link];
import [Link];

public class MainAbstrata {

public static void main(String[] args) {

Funcionario f = new Funcionario(){
public Double getBonus(){
return 100.;
}
};

[Link]("joao");
[Link](10000.);
[Link]("Nome: " + [Link]() + ", " +
"Salário Final: R$ " + ([Link]() + [Link]()));

5
 Apostila Java Básico Aula

Herança 07
Funcionario f1= new Estagiario();
[Link](10);
[Link]("carlos");
[Link](2000.);

[Link]("Bonus do estagiário: R$ " +

[Link]());
[Link]("Mensagem: " + [Link]());
}}

No console...

Nome: joao, Salário Final: R$ 10100.0

Bonus do estagiario: R$ 200.0
Mensagem: Sub Classe Estagiario

6
 Apostila Java Básico Aula

Grava Arquivo 08
Classe Cliente, gravação de Arquivo

Criar um projeto -> Aula08

Criar um pacote chamado entity.
Criar uma classe Cliente contendo os atributos (idCliente, nome, email), os
contrutores vazio e cheio, toString, e getters e setters, implementar os métodos
equals e hashCode.

package entity;

public class Cliente{

private Integer idCliente;

private String nome;
private String email;

public Cliente() {
}

public Cliente(Integer idCliente, String nome, String email)

{
super();
[Link] = idCliente;
[Link] = nome;
[Link] = email;
}

@Override
public String toString() {
return "Cliente [idCliente=" + idCliente + ", nome=" +
nome + ", email=" + email + "]";
}

public Integer getIdCliente() {

return idCliente;
}
public void setIdCliente(Integer idCliente) {
[Link] = idCliente;
}
public String getNome() {
return nome;

[Link] 1
 Apostila Java Básico Aula

Grava Arquivo 08
}
public void setNome(String nome) {
[Link] = nome;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
[Link] = email;
}

No método equals vamos comparar através do idCliente. E no método

hashCode vamos ordenar.

@Override
public boolean equals(Object o){
Cliente c = (Cliente) o;
return [Link]([Link]());
}

@Override
public int hashCode(){
return [Link](idCliente).length();
}
}

Criar uma classe chamada ManagerBeanCliente para manipular as operações

de Cliente. Criar o atributo da lista de cliente, através da interface List e dar
o nome de lista para o objeto criado.

package manager;

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class ManagerBeanCliente {

private List<Cliente> lista;

[Link] 2
 Apostila Java Básico Aula

Grava Arquivo 08

No construtor iniciar o objeto da lista e dar espaço de memória para

trabalhar através da interface do ArrayList.

public ManagerBeanCliente() {
lista = new ArrayList<Cliente>();
}

public List<Cliente> getLista() {

return lista;
}
public void adicionar(Cliente c) {
[Link](c);
}

Criar um método para remover os clientes cadastrados, passar o Cliente

como parâmetro e criar o objeto. Se a lista contém (método booleano
contains, que retorna “true” ou “false”) algum objeto, ela remove buscando
pelo índice, senão imprime a mensagem.

public void remove(Cliente c) {

if ([Link](c)) {
[Link]([Link]([Link](c)));
} else {
[Link]("Dado não encontrado...");
}
}

Criar um método para ordenar pelo código utilizando o método Comparator,

que ordena. Chama o método, passa o parâmetro Cliente, depois o objeto e
dá o espaço de memória. Chama um outro método publico, o compare e
passa como parâmetros os clientes c1 e c2. Retornando a comparação entre
o c1 e o c2 atraves do compareTo. Chamamos a classe Collections e o
método sort para trazer a lista ordenada.

public void ordenaPeloCodigo(){

Comparator <Cliente> comp = new Comparator<Cliente>(){
public int compare(Cliente c1, Cliente c2){

[Link] 3
 Apostila Java Básico Aula

Grava Arquivo 08
return [Link]().compareTo([Link]());
}
};
[Link](lista, comp);
}

No teste da main, chamar a classe ManagerBeanCliente, criar o objeto e dar

espaço na memória. Criar 4 clientes e através do objeto “mb”, chamar o
método adicionar para inserir os clientes criados. Pedir para ordenar e
depois imprimir pelo getLista.

public static void main(String[] args) {

ManagerBeanCliente mb = new ManagerBeanCliente();
Cliente c1 = new Cliente(10, "jose", "jose@[Link]");
Cliente c2 = new Cliente(13, "leo", "leo@[Link]");
Cliente c3 = new Cliente(7, "vitor",
"vitor@[Link]");
Cliente c4 = new Cliente(20, "Pedro",
"pedro@[Link]");

[Link](c1);
[Link](c2);
[Link](c3);
[Link](c4);
[Link]();
[Link]([Link]());

Agora através da lista, vamos inserir valores nessa lista. Chamar a classe
Lista, passar o tipo Integer como parâmetro, criar objeto e dar espaço de
memória com o ArrayList. Inserir os valores no objeto através do método
“add” e passar os valores como parâmetro.

List <Integer> lst = new ArrayList <Integer>();

[Link](new Integer(10));
[Link](200);
[Link](11);
[Link](21);

Chamar a classe Comparator, criar objeto e dar espaço. Implementar o

método de ordenação, “compare”, passar os parâmetros tipado e retornar o
tipo de comparação feita.

[Link] 4
 Apostila Java Básico Aula

Grava Arquivo 08

Comparator<Integer> comp = new Comparator<Integer>(){

@Override
public int compare(Integer i1, Integer i2){
return [Link](i2);
}
};

Chamar a classe Collections,o método “sort” para ordenar e passar os

parâmetros. No primeiro método de impressão pedimos para imprimir o
índice do numero 11, na lista, isto é, em que posição ele se encontra. Na
segunda impressão, a lista ordenada. Na terceira imprssão, o valor.

[Link](lst, comp);
[Link]("Indice :" + [Link](11));
[Link](lst);
[Link]("Valor: " + [Link]([Link](21)) );

}
}

Criar um pacote chamado “io” para a manipulação dos arquivos. Clicar no

pacote criado -> New -> Interface. Dar o nome de IArquivo para a Interface
criada.

[Link] 5
 Apostila Java Básico Aula

Grava Arquivo 08

Criar os métodos open, writeArquivo e close. Os métodos serão sem corpo

pois serão implementados na classe que herdar essa interface. São métodos
para abrir o arquivo, escrever e fechar.

[Link] 6
 Apostila Java Básico Aula

Grava Arquivo 08
package io;

import [Link];

public interface IArquivo {

public void open() throws Exception;

public void writeArquivo(Cliente c) throws Exception;
public void close() throws Exception;

Criar uma classe Arquivo que herdara a Interface IArquivo e implementará

os seus métodos.

package io;

import [Link];
import [Link];
import [Link];

public class Arquivo implements IArquivo {

Chamar a classe FileWritter responsável pela gravação em local

determinado, para trabalhar com os arquivos e criar seu objeto.
Implementar os métodos abstratos herdados da Interface.

O método open fica responsável por abrir e criar o arquivo. Chamar a classe
File e criar o objeto, depois indicar o caminho do diretório onde o arquivo
ficará. Se exisitir o diretório, exibirá uma mensagem. Se não existir, criará o
diretório e exibirá a mensagem. Então o arquivo será criado.

FileWriter fw;

@Override
public void open() throws Exception {
File f = new File("c:/javabasico");
if ([Link]()){
[Link]("Diretorio Existente ...");
}else{
[Link]();
[Link]("Diretorio Criado ...");

[Link] 7
 Apostila Java Básico Aula

Grava Arquivo 08
}
fw = new FileWriter("c:/javabasico/[Link]",true);
}

O método writeArquivo é para gravar as informações nele. Pegando as

informações do toString do Cliente e separando pulando linha.

@Override
public void writeArquivo(Cliente c) throws Exception {
[Link]([Link]() + "\n");
}

O método close é para fechar o arquivo. O objeto atualiza com o método

flush e depois fecha.

@Override
public void close() throws Exception {
[Link]();
[Link]();
}

No main, usar o bloco try e catch e criar um cliente com seus dados. É
preciso usar o bloco de try e catch pois foi usado o throws Exception nos
métodos. Chamar a classe Arquivo com o objeto e o espaço para trabalhar.
Chamar os métodos na ordem: open, writeArquivo, passando o objeto, e
close. Imprimir uma mensagem de sucesso. Caso dê errado, cai no catch e
exibe a mensagem de erro.

public static void main(String[] args) {

try{
Cliente c = new Cliente (11,"Diogo","diogo@[Link]");
Arquivo arq = new Arquivo();
[Link]();
[Link](c);
[Link]();
[Link]("Dados gravados do Cliente");
}catch(Exception ex){
[Link]("Error :" + [Link]());
}

[Link] 8
 Apostila Java Básico Aula

Grava Arquivo 08
}
}

Como não havia o diretório, foi criado e exibido a mensagem. Depois foi
criado o arquivo com os dados.

[Link] 9
 Apostila Java Básico Aula

Grava Arquivo 08
Foi criado um arquivo em formato txt contendo os dados.

[Link] 10
 Apostila Java Básico Aula

JUnit, Validação 09
Classe Aluno e Disciplina, Validação JUnit, gravação
no MySql

Criar um projeto -> Aula09

Criar um pacote chamado entity.
Criar uma classe Aluno contendo os atributos (idAluno, nome, email,
listaDisciplina, cr, ativo), o relacionamento do Aluno com a classe Disciplina,
o contrutor vazio, construtor cheio (sem os atributos: cr e ativo, pois serão
calculados), construtor cheio(sem cr, ativo e relacionamento com a classe
Disciplina), toString, e getters e setters.

package entity;

import [Link];

public class Aluno {

private Integer idAluno;

private String nome;
private String email;
private Double cr = 0.;
private Boolean ativo;

private List<Disciplina> listaDisciplina;

public Aluno() {

public Aluno(Integer idAluno, String nome, String email) {

super();
[Link] = idAluno;
[Link] = nome;
[Link] = email;
}

public Aluno(Integer idAluno, String nome, String email,

List<Disciplina> listaDisciplina) {
super();
[Link] = idAluno;
[Link] = nome;

[Link] 1
 Apostila Java Básico Aula

JUnit, Validação 09
[Link] = email;
[Link] = listaDisciplina;
}

@Override
public String toString() {
return "Aluno [idAluno=" + idAluno + ", nome=" + nome +
", email=" + email + ", listaDisciplina=" + listaDisciplina + ",
cr=" + cr + "]";
}

public Integer getIdAluno() {

return idAluno;
}
public void setIdAluno(Integer idAluno) {
[Link] = idAluno;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
[Link] = email;
}
public List<Disciplina> getListaDisciplina() {
return listaDisciplina;
}
public void setListaDisciplina(List<Disciplina>
listaDisciplina) {
[Link] = listaDisciplina;
}
public Double getCr() {
return cr;
}
public void setCr(Double cr) {
[Link] = cr;
}
public Boolean getAtivo() {
return ativo;
}
public void setAtivo(Boolean ativo) {

[Link] 2
 Apostila Java Básico Aula

JUnit, Validação 09
[Link] = ativo;
}
}

Criar a classe de Disciplina com os atributos (código, disciplina, nota1,

nota2, media, situacao) que se relacionará com a classe Aluno, colocar o
relacionamento com o Aluno, construtor vazio, construtor cheio (sem os
satributos a serem calculados), construtor cheio (sem os satributos a serem
calculados e sem o relacionamento com a classe Aluno), toString e getters e
setters.

package entity;

public class Disciplina {

private Integer codigo;

private String disciplina;
private Double nota1;
private Double nota2;
private transient Double media = 0.;
private String situacao = "";

private Aluno aluno;

public Disciplina() {

public Disciplina(Integer codigo, String disciplina, Double

nota1, Double nota2, Aluno aluno) {
super();
[Link] = codigo;
[Link] = disciplina;
this.nota1 = nota1;
this.nota2 = nota2;
[Link] = aluno;
}

public Disciplina(Integer codigo, String disciplina, Double

nota1, Double nota2) {
super();
[Link] = codigo;

[Link] 3
 Apostila Java Básico Aula

JUnit, Validação 09
[Link] = disciplina;
this.nota1 = nota1;
this.nota2 = nota2;
}

@Override
public String toString() {
return "Disciplina [codigo=" + codigo + ", disciplina="
+ disciplina + ", nota1=" + nota1 + ", nota2=" + nota2 + ",
media=" + media + ", situacao=" + situacao + "]";
}

public Integer getCodigo() {

return codigo;
}
public void setCodigo(Integer codigo) {
[Link] = codigo;
}
public String getDisciplina() {
return disciplina;
}
public void setDisciplina(String disciplina) {
[Link] = disciplina;
}
public Double getNota1() {
return nota1;
}
public void setNota1(Double nota1) {
this.nota1 = nota1;
}
public Double getNota2() {
return nota2;
}
public void setNota2(Double nota2) {
this.nota2 = nota2;
}
public Double getMedia() {
return media;
}
public void setMedia(Double media) {
[Link] = media;
}
public String getSituacao() {
return situacao;
}
public void setSituacao(String situacao) {

[Link] 4
 Apostila Java Básico Aula

JUnit, Validação 09
[Link] = situacao;
}
public Aluno getAluno() {
return aluno;
}
public void setAluno(Aluno aluno) {
[Link] = aluno;
}
}

Criar um pacote chamado control e criar uma classe ValidaAluno dentro

desse pacote para a validação dos dados de Aluno. Serão criado métodos
booleanos para validação campo a campo de cada atributo.

package control;

import [Link];
import [Link];
import [Link];

public class ValidaAluno {

No método Booleano validaCodigo passamos o parâmetro do Aluno e o

objeto a, onde iremos verificar se o Id do Aluno é válido, passamos também
o throws que se houver algum erro, o programa lançará uma exceção, um
tipo de erro. Se o Id for menor ou igual a 0 (zero) gera um erro de exceção
e imprime uma mensagem referente a esse erro, se não, se for válido,
retorna verdadeiro.

public Boolean validaCodigo(Aluno a) throws Exception {

if ([Link]() <= 0) {
throw new IllegalArgumentException(
"Codigo Invalido ...Nao pode ser Nulo ou Negativo");
}

return true;
}

[Link] 5
 Apostila Java Básico Aula

JUnit, Validação 09
No método Booleano validaNome passamos o parâmetro do Aluno a, onde
iremos verificar se o nome é válido. Se o nome for nulo, gera um erro de
exceção e uma mensagem, se o nome tiver tamanho igual a 0 (zero) , ou
seja vazio, também gera um erro e imprime mensagem. Se passar por essas
validações passamos as regras.

Chamamos a classe Pattern, responsável pelos padrões de regra e criamos

um objeto. Através de Pattern chamamos o método compile e passamos a
regra, o padrão a ser seguido. Na classe Matcher que pesquisará a regra
também criamos um objeto e relacionamos esse o objeto da Pattern com a
Matcher (padrão com pesquisa) e passamos que o parâmetro é o nome do
Aluno. Se a pesquisa for diferente da regra gera um erro e uma mensagem,
se não, dá true, o nome está dentro da regra.

public Boolean validaNome(Aluno a) {

if ([Link]() == null){
throw new IllegalArgumentException("Nome nao pode
ser NULL ...");
}
if ([Link]().length() == 0){
throw new IllegalArgumentException("Nome nao pode
ser vazio ...");
}
Pattern p = [Link]("[A-Z a-z]{2,35}");
Matcher m = [Link]([Link]());
if (![Link]()) {
throw new IllegalArgumentException("Nome Invalido
...");
}
return true;
}

Para o método validaEmail, chamaremos a classe Pattern, depois a classe

Matcher. Se a pesquisa der diferente gera um erro e uma mensagem. Se
não, retorna verdadeiro.

public Boolean validaEmail(Aluno a) {

Pattern p = [Link](".+@.+\\.[a-z]+");
Matcher m = [Link]([Link]());
if (![Link]()) {
throw new IllegalArgumentException("Email Invalido
...");

[Link] 6
 Apostila Java Básico Aula

JUnit, Validação 09
}
return true;
}

Para o método validaCr, se o cr for menor que 0 (zero) ou maior que 10,
gera um erro e imprime a mensagem, se não retorna verdadeiro.

public Boolean validaCr(Aluno a) {

if ([Link]() < 0 | [Link]() > 10) {
throw new IllegalArgumentException("Cr Invalido
...");
}
return true;
}

Para o método validaAtivo, se o aluno for diferente de ativo gera o erro com
mensagem, se não, ele é ativo, verdadeiro.

public Boolean validaAtivo(Aluno a) {

if (![Link]()) {
throw new IllegalArgumentException("Aluno Inativo
...");
}
return true;
}

No main, iremos fazer os testes de validação dentro do bloco try e catch.

Criamos um Aluno com seus dados. Passamos se ele está ativo e o valor do
“cr” dele. Chamamos a classe de validação, ValidaAluno, criamos seu objeto
e damos espaço de memória. Chamamos cada método para ser verificado.
Imprimimos uma mensagem se tudo estiver correto e concatenamos com o
toString de Aluno. Se der errado, vai para o catch e imprime o erro.

public static void main(String[] args) {

try {
Aluno a = new Aluno(10, "jose", "jose@[Link]");
[Link](true);
[Link](3.);

ValidaAluno va = new ValidaAluno();

[Link] 7
 Apostila Java Básico Aula

JUnit, Validação 09
[Link](a);
[Link](a);
[Link](a);
[Link](a);
[Link](a);

[Link]("Aluno Valido ..." + a);

} catch (Exception ex) {
[Link]([Link]());
}
}
}

Criar uma classe Main para relacionar a classe Aluno com a classe Disciplina.
O Aluno terá uma lista de disciplinas. Criar o método main para executar o
teste.

Criar um objeto aluno com seus dados(idAluno, nome, email). Relacionar o

objeto de Aluno com setListaDisiciplina passando o ArrayList de Disicplina,
que é o espaço para trabalharmos com essa lista. Chamar o objeto “a” de
aluno e passar quais disciplina esse aluno possui através do método add, dar
espaço para Disciplina e passar os dados dessa Disciplina(codigo, disciplina,
nota1, nota2).

[Link] 8
 Apostila Java Básico Aula

JUnit, Validação 09

package entity;

import [Link];

public class Main {

public static void main(String[] args) {

Aluno a = new Aluno(100, "pedro", "pedro@[Link]");

[Link](new ArrayList<Disciplina>());

[Link]().add(new Disciplina(10, "java", 3., 4.5));

[Link]().add(new Disciplina(11, "oracle",1., 2.));

Criar um “for” para calcular a media e a situação de quantas disciplinas o

aluno tiver em sua lista. Dentro do “for” passar a classe Disciplina, criar um
objeto para Disciplina e passar a lista que o aluno possui. O objeto de
Disciplina passa o objeto de Aluno como parâmetro, depois chama setMedia
onde passa a fórmula de cálculo da média e por último chama a situação
passando a condição de aprovação ou reprovação. Por fim, imprime o objeto
aluno com suas disciplinas já calculadas.

for (Disciplina x : [Link]()) {

[Link](a);
[Link]((x.getNota1() + x.getNota2()) / 2);
[Link](([Link]() >= 6) ? "aprovado" :
"reprovado");
}
[Link](a);
}
}

Resultado no console...

Aluno [idAluno=100, nome=pedro, email=pedro@[Link],

listaDisciplina=[Disciplina [codigo=10, disciplina=java,
nota1=3.0, nota2=4.5, media=3.75, situacao=reprovado],
Disciplina [codigo=11, disciplina=oracle, nota1=1.0, nota2=2.0,
media=1.5, situacao=reprovado]], cr=0.0]

[Link] 9
 Apostila Java Básico Aula

JUnit, Validação 09

Criar um pacote chamado test e criar uma classe chamada TestAluno. Para
habilitar o teste utilizando o JUnit, clicar com o botão direito no projeto,
clicar na aba Libraries e depois Add Library.

[Link] 10
 Apostila Java Básico Aula

JUnit, Validação 09
Próximo passo: Clicar em Junit e depois Next.

Finish.

[Link] 11
 Apostila Java Básico Aula

JUnit, Validação 09

package test;

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class TestAluno {

Criar o atributo da classe aluno e passar o objeto aluno. No método init será
instanciando o objeto de aluno e seu espaço de memória. A anotação
@Before indica que esse método será rodado primeiro que os outros
métodos.

private Aluno aluno;

@Before
public void init(){
aluno = new Aluno();
}

[Link] 12
 Apostila Java Básico Aula

JUnit, Validação 09
Criaremos um método de teste para impor as regras de nome. Pela anotação
@Test indicamos que esse método é um teste que será executado depois do
método com a anotação @Before.

@Test
public void testQuantidadeLimiteNome(){
[Link]("aa");
[Link]("Nome fora da faixa de 2 a 35",
new ValidaAluno().validaNome(aluno));
}

Criaremos um outro método de teste para impor outras regras de nome.

@Test
public void testConteudoNome(){
[Link]("");
[Link]("Nome não pode ter caracter especial",
new ValidaAluno().validaNome(aluno));

}
}

Para testar a classe, clicar com o botão direito na classe, ir para Run as,
depois JUnit Test.

[Link] 13
 Apostila Java Básico Aula

JUnit, Validação 09

Nesse teste, o exemplo usado não passou, deu resultado vermelho, isto é,
foi pego no teste de verificação. No método testConteidoNome estava vazio
o campo nome.

[Link] 14
 Apostila Java Básico Aula

JUnit, Validação 09
Se modificarmos a classe teremos um novo resultado.

package test;

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class TestAluno {

private Aluno aluno;

@Before
public void init(){
aluno=new Aluno();
}

@Test
public void testQuantidadeLimiteNome(){
[Link]("luciana");
[Link]("Nome fora da faixa de 2 a 35",
new ValidaAluno().validaNome(aluno));
}

@Test
public void testConteudoNome(){
[Link]("Luciana");
[Link]("Nome não pode ter caracter especial",
new ValidaAluno().validaNome(aluno));
}
}

[Link] 15
 Apostila Java Básico Aula

JUnit, Validação 09
Os nomes passados estão dentro das regras, então o resultado do teste
ficou verde.

Criando o banco de dados:

Para criar o script do banco de dados, criar um pacote chamado persistence.
Depois clicar no pacote, new e Other.

[Link] 16
 Apostila Java Básico Aula

JUnit, Validação 09

Depois SQL Development, SQL File e Next.

[Link] 17
 Apostila Java Básico Aula

JUnit, Validação 09
Em File name, colocar o nome do script e clicar em Next.

Depois de criado o arquivo com o SQL do banco. Digitar os comando para

criação do banco.

Comandos: Explicação:
drop database if exists aula1; Apagar o banco se já existir com o
nome de aula1.
create database aula1; Criar um banco com o nome de
aula1.
show databases; Mostrar os bancos existentes na sua
máquina.
use aula1; Usar o banco aula1.
show tables; Mostrar as tabelas desse banco.

[Link] 18
 Apostila Java Básico Aula

JUnit, Validação 09
Copiar esses comandos para a janela do MySql.

Criar no pacote persistence a classe Dao. Classe responsável pela conexão

com o banco de dados. Todas as importações virão do pacote [Link].*

package persistence;

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class Dao {

Chamamos as classes de manipulação do banco onde Connection é
responsável pela conexão com o banco, PreparedStatement responsável pelo
acesso (gravar, alterar, excluir ou consultar) a tabela do banco, resultSet
pelas consultas com o comando select e CallableStatement pelas
procedures.

Connection con;
PreparedStatement stmt;
ResultSet rs;

[Link] 19
 Apostila Java Básico Aula

JUnit, Validação 09
CallableStatement call;

Criamos um método para abertura do banco e conexão. Chamamos a classe

Class e o método forName e passamos o diretório onde está o driver de
conexão com o MySql. Pelo objeto con, chamamos a classe de
gerenciamento dessa conexão e passamos o método de conexão
getConnection com os parâmetros de conexão ao banco, usuário e senha.

public void open() throws Exception{

[Link]("[Link]");
con = DriverManager.
getConnection("jdbc:mysql://localhost:3306/aula1","root","coti")
;
}

Criamos um método para fecha a conexão com o banco. Passamos o objeto

con e o método close.

public void close() throws Exception{

[Link]();
}

Criar um pacote chamado manager e uma classe ManagerBean para

gerenciar a lista de disciplinas que a classe Aluno possui. Passar a classe
Aluno como atributo e criar o objeto dele.

package manager;

import [Link];
import [Link];
import [Link];

public class ManagerBean {

[Link] 20
 Apostila Java Básico Aula

JUnit, Validação 09
private Aluno aluno;

Criar um construtor passando a classe Aluno como parâmetro e o objeto.

Com a palavra reservada this, que faz referencia a própria classe e nesse
caso, ao atributo aluno e passamos o objeto. Depois passaremos a lista de
disciplinas para esse aluno.

public ManagerBean(Aluno a) {
[Link] = a;
[Link](new
ArrayList<Disciplina>());
}

public Aluno getAluno() {

return aluno;
}

Criar um método para adicionar as disciplinas, passar a classe Disciplina

como parâmetro e o objeto. No corpo do método, charamr o objeto de aluno
e relacionar com as disciplinas, já adicionando.

public void add(Disciplina d) {

[Link]().add(d);
}

No método main, chamamos a classe e depois um objeto e então damos

espaço para trabalhar passando a criação de um novo aluno com seus
dados. Passamos o objeto e em seguida o método add, adicionando as
disciplina para o aluno. Pedimos para imprimir através do objeto e o
getAluno.

public static void main(String[] args) {

ManagerBean mb = new ManagerBean(new Aluno(10,
"stuart", "stuart@[Link]"));
[Link](new Disciplina(10, "java", 1.2, 2.1));
[Link](new Disciplina(11, "OCJA", 2.2, 2.4));
[Link]([Link]());
}

[Link] 21
 Apostila Java Básico Aula

JUnit, Validação 09
}

No console...

Aluno [idAluno=10, nome=stuart, email=stuart@[Link],

listaDisciplina=[Disciplina [codigo=10, disciplina=java,
nota1=1.2, nota2=2.1, media=0.0, situacao=], Disciplina
[codigo=11, disciplina=OCJA, nota1=2.2, nota2=2.4, media=0.0,
situacao=]], cr=0.0]

[Link] 22
 Apostila Java Básico Aula

ManyToMany 10
JAVA BÁSICO – Relacionamento ManyToMany

Criar um projeto -> Aula10.

Criar no pacote entity a classe Médico com os atributos(idMedico,
nomeMedico, especialização e a lista de pacientes). Colocar a interface
Comparable para furuta ordenação. Criar também o construtor vazio, cheio
completo com a lista de pacientes, um outro cheio sem a lista, um somente
com a lista, o toString com os atributos menos a lista de pacientes, os
getters e setters métodos equals e compareTo.

package entity;

import [Link];
import [Link];

public class Medico implements Comparable<Medico>{

private Integer idMedico;

private String nomeMedico;
private String especializacao;
private List<Paciente> pacientes;

public Medico() {
}

public Medico(Integer idMedico, String nomeMedico, String

especializacao, List<Paciente> pacientes) {
[Link] = idMedico;
[Link] = nomeMedico;
[Link] = especializacao;
[Link] = pacientes;
}

public Medico(Integer idMedico, String nomeMedico, String

especializacao) {
[Link] = idMedico;
[Link] = nomeMedico;
[Link] = especializacao;
}

[Link]
 Apostila Java Básico Aula

ManyToMany 10
public Medico(List<Paciente> pacientes) {
[Link] = pacientes;
}

@Override
public String toString() {
return "Medico [idMedico=" + idMedico + ", nomeMedico="
+ nomeMedico + ", especializacao=" + especializacao + "]";
}

public Integer getIdMedico() {

return idMedico;
}
public void setIdMedico(Integer idMedico) {
[Link] = idMedico;
}
public String getNomeMedico() {
return nomeMedico;
}
public void setNomeMedico(String nomeMedico) {
[Link] = nomeMedico;
}
public String getEspecializacao() {
return especializacao;
}
public void setEspecializacao(String especializacao) {
[Link] = especializacao;
}
public List<Paciente> getPacientes() {
return pacientes;
}
public void setPacientes(List<Paciente> pacientes) {
[Link] = pacientes;
}

Criamos um método para adicionar pacientes passando como parâmetro a

classe Paciente e o objeto. Inserimos uma condição, se paciente for nulo,
estiver vazio, instancia a lista passando espaço de memória para adição de
pacientes nessa lista. Em seguida chamamos a lista com o método add para
adicionar os pacientes através do objeto p.

public void adicionar(Paciente p){

[Link]
 Apostila Java Básico Aula

ManyToMany 10
if (pacientes==null){
pacientes = new ArrayList<Paciente>();
}
[Link](p);
}

Criar um método remover passando como parâmetro a classe Paciente com

seu objeto. Colocamos uma condição de que se houver paciente na lista e se
paciente contiver o objeto p, passamos o método remove, que removerá
pelo índice. Se não, se o paciente não for encontrado pelo índice, ou seja,
não existir, o programa retorna uma mensagem de que o paciente não foi
encontrado. Se não for nenhuma dessas condições, retorna a mensagem
que a lista está vazia.

public void remover(Paciente p){

if (pacientes!=null){
if ([Link](p)){
[Link]([Link]([Link](p)));
}else{
[Link]("Nao encontrado o paciente");
}
}else{
[Link]("Esta vazio a Lista");
}
}

public boolean equals(Object o){

Medico m = (Medico) o;
return [Link]([Link]());
}

@Override
public int compareTo(Medico m) {
return [Link]([Link]()) ;
}
}

Criar uma classe Paciente com os atributos (idPaciente, nomePaciente e com

o relacionamento da lista de medicos). Criar o contrutor vazio, construtor
cheio completo (com a lista de Médicos), construtor cheio sem a lista de

[Link]
 Apostila Java Básico Aula

ManyToMany 10
Médicos, toString de todos os atributos, os getters e setters e métodos
equals e compareTo.

package entity;

import [Link];
import [Link];

public class Paciente implements Comparable<Paciente>{

private Integer idPaciente;

private String nomePaciente;
private List<Medico> medicos;

public Paciente() {

public Paciente(Integer idPaciente, String nomePaciente) {

[Link] = idPaciente;
[Link] = nomePaciente;
}

public Paciente(Integer idPaciente, String nomePaciente,

List<Medico> medicos) {
[Link] = idPaciente;
[Link] = nomePaciente;
[Link] = medicos;
}

public Paciente(List<Medico> medicos) {

[Link] = medicos;
}

@Override
public String toString() {
return "Paciente [idPaciente=" + idPaciente + ",
nomePaciente=" + nomePaciente + ", medicos=" + medicos + "]";
}

public Integer getIdPaciente() {

[Link]
 Apostila Java Básico Aula

ManyToMany 10
return idPaciente;
}
public void setIdPaciente(Integer idPaciente) {
[Link] = idPaciente;
}
public String getNomePaciente() {
return nomePaciente;
}
public void setNomePaciente(String nomePaciente) {
[Link] = nomePaciente;
}
public List<Medico> getMedicos() {
return medicos;
}
public void setMedicos(List<Medico> medicos) {
[Link] = medicos;
}

public void adicionar(Medico m){

if (medicos==null){
medicos = new ArrayList<Medico>();
}
[Link](m);
}

public void remover(Medico m){

if (medicos!=null){
if([Link](m)){
[Link]([Link]([Link](m)));
}else{
[Link]("Nao Encontrado");
}
}else{
[Link]("Medico Vazio");
}
}

@Override
public int compareTo(Paciente p) {
return [Link]([Link]());
}

@Override

[Link]
 Apostila Java Básico Aula

ManyToMany 10
public boolean equals(Object obj) {
Paciente p = (Paciente) obj;
return [Link]([Link]());
}
}

Criar a classe para teste Main e o método main. Criar alguns pacientes com
seus dados, depois criar médicos e em seguida relacionar.

package entity;

import [Link];
import [Link];

public class Main {

public static void main(String[] args) {

Paciente p1 = new Paciente(10,"stuart");
Paciente p2 = new Paciente(11,"lu");
Paciente p3 = new Paciente(12,"andre");

Medico m1 = new Medico(100,"pedro","fonoaudiologo");

Medico m2 = new Medico(101,"globinho","psiquiatra");

Estamos relacionando o objeto m1 do medico através do método adicionar

com o objeto p1 do Paciente. Significa que o médico m1 terá 3 pacientes. Já
o médico m2 terá apenas um paciente. Ou seja, o paciente p1, será paciente
de 2 médicos.

[Link](p1);
[Link](p2);
[Link](p3);
[Link](p1);

[Link](m1);
[Link](m2);
}
}

[Link]
 Apostila Java Básico Aula

ManyToMany 10
No console...

Medico [idMedico=100, nomeMedico=pedro,

especializacao=fonoaudiologo, pacientes=[Paciente
[idPaciente=10, nomePaciente=stuart, medicos=null], Paciente
[idPaciente=11, nomePaciente=lu, medicos=null], Paciente
[idPaciente=12, nomePaciente=andre, medicos=null]]]

Medico [idMedico=101, nomeMedico=globinho,

especializacao=psiquiatra, pacientes=[Paciente [idPaciente=10,
nomePaciente=stuart, medicos=null]]]

[Link]
 Apostila Java Básico Aula

JDBC 11
Criar um projeto -> Aula11.
Criar no pacote entity a classe Funcionario com os atributos(idFuncionario,
nome, sexo, ativo, salario). Criar construtor vazio, o construtor cheio, o
toString com todos os atributos e os getters e setters.

package entity;

public class Funcionario {

private Integer idFuncionario;

private String nome;
private String sexo;
private Boolean ativo;
private Double salario;

public Funcionario() {

public Funcionario(Integer idFuncionario, String nome,

String sexo, Boolean ativo, Double salario) {
super();
[Link] = idFuncionario;
[Link] = nome;
[Link] = sexo;
[Link] = ativo;
[Link] = salario;
}

@Override
public String toString() {
return "Funcionario [idFuncionario=" + idFuncionario +
", nome=" + nome + ", sexo=" + sexo + ", ativo=" + ativo + ",
salario=" + salario + "]";
}

public Integer getIdFuncionario() {

return idFuncionario;
}
public void setIdFuncionario(Integer idFuncionario) {
[Link] = idFuncionario;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {

[Link] 1
 Apostila Java Básico Aula

JDBC 11
[Link] = nome;
}
public String getSexo() {
return sexo;
}
public void setSexo(String sexo) {
[Link] = sexo;
}
public Boolean getAtivo() {
return ativo;
}
public void setAtivo(Boolean ativo) {
[Link] = ativo;
}
public Double getSalario() {
return salario;
}
public void setSalario(Double salario) {
[Link] = salario;
}
}

Para adicionar a biblioteca de conexão com o banco de “dadosmysql-

connector-java”, clicar com o botão direito no projeto, depois em Properties.

[Link] 2
 Apostila Java Básico Aula

JDBC 11
Clicar em Java Build Path e Add External JARs.

Indicar o caminho onde se encontra a biblioteca do mysql.

[Link] 3
 Apostila Java Básico Aula

JDBC 11
Depois de adicionar a lib, clicar em Apply e depois OK.

Indicando a lib no projeto.

[Link] 4
 Apostila Java Básico Aula

JDBC 11
Criando o banco de dados:
Para criar o script do banco de dados, criar um pacote chamado persistence.
Depois clicar no pacote, new e Other. Depois SQL Development, SQL File e
Next. Em File name, colocar o nome do script e clicar em Next. Depois de
criado o arquivo com o SQL do banco. Digitar os comando para criação do
banco.

Comandos: Explicação:
drop database if exists Apagar o banco se já existir com o nome
aula11; de aula11.
create database aula11; Criar um banco com o nome de aula11.
use aula11; Usar o banco aula11.

drop database if exists aula11;

create database aula11;
use aula2;

Comandos: Explicação:
create table Criar a tabela com nome de funcionário.
primary key Significa que o campo será a chave
primária.
varchar Siginifica que o campo é uma palavra com
35 caracteres.
not null O campo não poderá ser nulo, vazio.
enum Significa que o campo só tem duas opções
“m” ou “f”.
double Significa que o campo é do tipo Double,
valor.
int Significa que o campo é do tipo inteiro.

create table funcionario(idFuncionario int primary key,

nome varchar (35) not null,
sexo enum ('m','f') not null,
salario double,
ativo int);

Comandos: Explicação:

[Link] 5
 Apostila Java Básico Aula

JDBC 11
desc Comando para dar a descrição da tabela.
insert into “nome da Insere na tabela “funcionário” os valores
tabela” values (...)
select * from “nome da Comando que seleciona todos os campos
tabela” da tabela funcionário.
select Seleciona
* Todos
from “tabela” Se refere a tabela desejada.

desc funcionario;

insert into funcionario values (100,'jose','m',1000,0);

insert into funcionario values (101,'stuart','m',1800,1);
insert into funcionario values (102,'carla','f',7800,1);

select * from funcionario;

No banco...

[Link] 6
 Apostila Java Básico Aula

JDBC 11

Criar um pacote chamado persistence e nele criar uma classe chamada Dao.
Essa classe é destinada para conexão ao banco de dados. DAO significa Data
Access Object.

package persistence;

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class Dao {

Connection con;
PreparedStatement stmt;
ResultSet rs;
CallableStatement call;

public void open() throws Exception{

[Link]("[Link]");
con = DriverManager.

[Link] 7
 Apostila Java Básico Aula

JDBC 11
getConnection("jdbc:mysql://localhost:3306/aula11","root","coti"
);
}

public void close() throws Exception{

[Link]();
}

Criar o método main para testar se a classe está se conectando ao banco.

Dentro do bloco try e catch chamar a classe e criar o seu objeto e dar
espaço de memória. Através do objeto abrir e depois fechar. Imprimir a
mensagem se conseguiu conectar. Se não conseguir, vai para o catch e
imprime a mesnagemd de erro.

public static void main(String[] args) {

try {
Dao d = new Dao();
[Link]();
[Link]();
[Link]("Banco de Dados OK!");
} catch (Exception e) {
[Link]("ERROR: " + [Link]());
}
}
}

No console...

Banco de Dados OK!

Criar a classe FuncionarioDao para manipular o funcionário dentro do banco.

package persistence;

import [Link];
import [Link];
import [Link];

[Link] 8
 Apostila Java Básico Aula

JDBC 11
public class FuncionarioDao extends Dao {

Criamos o método de criação do funcionário, passamos a classe Funcionario

e objeto como parâmetros. Chamamos o método para abrir o banco.

Chamamos a conexão com a tabela, depois a conexão com o banco através

do método de acesso a tabela passando os parâmetros SQL de inserção dos
dados do funcionário, onde as interrogações serão os dados a serem
passados.

public void create(Funcionario f)throws Exception{

open();
stmt = con.
prepareStatement("insert into funcionario values
(?,?,?,?,?)");

Em seguida passamos a conexão com a tabela e setamos o tipo do dados

que será recebido, nos parâmetros indicamos a posição da coluna e o objeto
de funcionário com o método get referente ao campo que será inserido.
Assim será feito para todos os dados.

[Link](1,[Link]());
[Link](2,[Link]());
[Link](3,[Link]());
[Link](4,[Link]());

No parâmetro referente se o funcionário está ativo, colocamos que ele

receberá 1 ou 0, será ativo ou não.

Fazemos a conexão com a tabela novamente, através do método execute,

executamos as ações de cima. Ainda usando a conexão, fechamos a tabela e
por fim, fechamos o banco.

[Link](5, ([Link]())?1:0);
[Link]();
[Link]();
close();
}

[Link] 9
 Apostila Java Básico Aula

JDBC 11

Criamos o método para buscar todos os funcionários cadastrados de uma

vez através de uma lista. Abrimos o banco. Conectamos com a tabela e
passamos o parâmetro de busca SQL de todos os registros do banco.
Através do rs fazemos a consulta no banco, conectamos com a tabela e
executamos a pesquisa.

public List<Funcionario> findAll() throws Exception{

open();
stmt = [Link]("select * from funcionario");
rs = [Link]();

Criamos a lista de funcionário través da interface List, criamos o objeto lista

e damos espaço de memória para trabalhar. Em seguida, enquanto houver
registros preenchemos com os dados do funcionário. Para isso, chamamos a
classe e criamos um objeto e damos espaço de memória.

List<Funcionario> lista = new ArrayList<Funcionario>();

while([Link]()){
Funcionario f = new Funcionario();

Depois, pelo objeto de funcionário setamos o campo e através da consulta,

pelo rs, indicamos o tipo de campo da referencia, seja passando a posição
da coluna onde está o dado esperado ou passando o nome da coluna.
Passamos campo a campo os dados a serem trazidos do banco. No fim, após
passar todos os campos, chamamos o objeto lista e o método para
adicionar, tendo como parâmetro o objeto de funcionário. Fechamos o banco
e retornamos a lista já preenchida com as informações.

[Link]( [Link](1));
[Link]( [Link](2));
[Link]( [Link]("sexo"));
[Link]([Link](4));
[Link](( [Link](5) ==1 )?true:false);
[Link](f);
}
close();
return lista;

[Link] 10
 Apostila Java Básico Aula

JDBC 11
}

No método de teste main, abrimos o bloco try e catch e detro do try

chamamos a inteface da lista com a classe Funcionário como parâmetro e
criamos um objeto chamado resp. Chamamos a classe FuncionarioDao e o
método de busca findAll.

No loop do for, passamos a classe Funcionario e o objeto f para preencher o

objeto resp. Ou seja, vai fazer a busca no banco e enquanto houver
registros, em seguida imprime o objeto cheio com os resultados. Imprime
também a mensagem.

Se cair no catch, der erro, imprime a mensagem de erro e com o método

printSackTrace exibe o erro mais detalhadamente.

public static void main(String[] args) {

try {
List <Funcionario> resp = new FuncionarioDao().findAll();
for (Funcionario f : resp){
[Link](f);
}
[Link]("Funcionario listado com sucesso!");
} catch (Exception e) {
[Link]("ERROR: " + [Link]());
[Link]();
}
}
}

No console..

Funcionario [idFuncionario=100, nome=jose, sexo=m, ativo=false,

salario=1000.0]
Funcionario [idFuncionario=101, nome=stuart, sexo=m, ativo=true,
salario=1800.0]
Funcionario [idFuncionario=102, nome=carla, sexo=f, ativo=true,
salario=7800.0]

Funcionario listado com sucesso!

[Link] 11
 Apostila Java Básico Aula

JDBC 11

No banco...

[Link] 12
 Apostila Java Básico Aula

List - HashCode 12
Criar um projeto -> Aula12.
Criar no pacote entity a classe Usuario com os atributos(idUsuario,
nomeUsuario, login, senha). Implementar a interface Comparable. Criar
construtor vazio, o construtor cheio, o toString sem a impressão da senha e
os getters e setters.

package entity;

import [Link];
import [Link];
import [Link];
import [Link];

public class Usuario implements Comparable<Usuario>{

private Integer idUsuario;

private String nomeUsuario;
private String login;
private String senha;

public Usuario() {

public Usuario(Integer idUsuario, String nomeUsuario, String

login, String senha) {
super();
[Link] = idUsuario;
[Link] = nomeUsuario;
[Link] = login;
[Link] = senha;
}

Na criação do toString, não incluir o atributo senha pois senão será impresso
a senha.

@Override
public String toString() {
return "Usuario [idUsuario=" + idUsuario + ",
nomeUsuario=" + nomeUsuario + ", login=" + login +"]";
}

[Link] 1
 Apostila Java Básico Aula

List - HashCode 12
public Integer getIdUsuario() {
return idUsuario;
}
public void setIdUsuario(Integer idUsuario) {
[Link] = idUsuario;
}
public String getNomeUsuario() {
return nomeUsuario;
}
public void setNomeUsuario(String nomeUsuario) {
[Link] = nomeUsuario;
}
public String getLogin() {
return login;
}
public void setLogin(String login) {
[Link] = login;
}
public String getSenha() {
return senha;
}
public void setSenha(String senha) {
[Link] = senha;
}

Criamos o método equals com a classe Object e damos as seguintes

condições: se o objeto passado for igual a esse, retornará verdadeiro.
Senão, se o objeto for nulo, retornará falso. Se não, se o objeto for diferente
de Usuario, retorna falso. Ou senão, passamos a classe Usuario com seu
objeto e fazemos um casting transformando o Usuario no objeto obj, tendo
como retorno a comparação entre os códigos dos usuários.

public boolean equals(Object obj){

if (obj == this){
return true;
}else if (obj == null){
return false;
}else if (!(obj instanceof Usuario)){
return false;
}else{
Usuario u = (Usuario) obj;
return [Link]([Link]());
}

[Link] 2
 Apostila Java Básico Aula

List - HashCode 12
}

No método hashCode, iremos ordenar pela quantidade de dígitos contidos no

código dos usuários. Passamos a classe String e criamos uma variável
quantidade,

@Override
public int hashCode(){
String quantidade = [Link](idUsuario);
return [Link]();
}

No método compareTo, será comparado os códigos, o código já existente

com o código passado.

@Override
public int compareTo(Usuario u) {
return [Link]([Link]());
}

Criamos o metodo main para testar. Nele chamamos a classe Usuario e

passamos seu objeto. Depois damos espaço de memória e passamos os
dados para a criação dos usuários.

public static void main(String[] args) {

Usuario u2 = new Usuario(100,"jose","jose@[Link]","23432");

Usuario u3 = new Usuario(99,"carlos","carlos@[Link]","5555");
Usuario u4 = new Usuario(20,"jo","jo@[Link]","123");
Usuario u5 = new Usuario(30,"joao","joao@[Link]","546");
Usuario u6 = new Usuario(300,"lu","lu@[Link]","546");
Usuario u7 = new Usuario(1,"pedro","pedro@[Link]","546");

Através da interface List passamos o Usuario como parâmetro, criamos o

objeto lst e damos espaço para lista trabalhar. Pelo objeto lst adicionamos
os objetos dos usuários. Chamamos a classe Collection e o método sort e

[Link] 3
 Apostila Java Básico Aula

List - HashCode 12
passamos o objeto da lista. Em seguida pedimos para imprimir esse objeto
com o resultado da lista já ordenado pelo código.

List<Usuario> lst = new ArrayList<Usuario>();

[Link](u2);
[Link](u3);
[Link](u4);
[Link](u5);
[Link](lst);
[Link](lst);

Já na interface do HashSet passamos a classe usuário e um objeto lst2.

Damos espaço para trabalhar. Chamamos o objeto e adicionamos os
usuários. Depois imprimimos esse objeto ordenado pela quantdade de
caracteres.

HashSet<Usuario> lst2 = new HashSet<>();

[Link](u2);
[Link](u3);
[Link](u4);
[Link](u5);
[Link](u6);
[Link](u7);
[Link](lst2);
}
}

No console...

[Usuario [idUsuario=20, nomeUsuario=jo, login=jo@[Link]],

Usuario [idUsuario=30, nomeUsuario=joao, login=joao@[Link]],
Usuario [idUsuario=99, nomeUsuario=carlos,
login=carlos@[Link]], Usuario [idUsuario=100,
nomeUsuario=jose, login=jose@[Link]]]

[Usuario [idUsuario=1, nomeUsuario=pedro,

login=pedro@[Link]], Usuario [idUsuario=30, nomeUsuario=joao,
login=joao@[Link]], Usuario [idUsuario=20, nomeUsuario=jo,
login=jo@[Link]], Usuario [idUsuario=99, nomeUsuario=carlos,
login=carlos@[Link]], Usuario [idUsuario=300, nomeUsuario=lu,

[Link] 4
 Apostila Java Básico Aula

List - HashCode 12
login=lu@[Link]], Usuario [idUsuario=100, nomeUsuario=jose,
login=jose@[Link]]]

[Link] 5
 Apostila Java Básico Aula

Agregação - Cálculo 13
Criar um projeto -> Aula13.
Criar no pacote entity as classes Jogador, Equipe, Pontuacao e
GerenteProjeto. Na classe Jogador criar os atributos(idJogador, nome e
pontos). Fazer o relacionamento do jogador com a classe Pontuacao e
atributo pontuacao. Criar construtor vazio, o construtor cheio, o toString
sem a impressão da senha e os getters e setters.

package entity;

public class Jogador {

private Integer idJogador;

private String nome;
private transient Integer pontos = 0;

private Pontuacao pontuacao;

public Jogador() {

public Jogador(Integer idJogador, String nome, Integer

pontos) {
[Link] = idJogador;
[Link] = nome;
[Link] = pontos;
}

@Override
public String toString() {
return "Jogador [idJogador=" + idJogador + ", nome=" +
nome + ", pontos=" + pontos + "]";
}

public Integer getIdJogador() {

return idJogador;
}
public void setIdJogador(Integer idJogador) {
[Link] = idJogador;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}

[Link] 1
 Apostila Java Básico Aula

Agregação - Cálculo 13
public Integer getPontos() {
return pontos;
}
public void setPontos(Integer pontos) {
[Link] = pontos;
}
public Pontuacao getPontuacao() {
return pontuacao;
}
public void setPontuacao(Pontuacao pontuacao) {
[Link] = pontuacao;
}
}

Na classe Pontuacao, criar os atributos idCartao e cor. Relacionar a classe

Pontuação com a classe Jogador e seu atributoo jogador. Criar os
construtores vazio e cheio, toString e getters e setters.

package entity;

public class Pontuacao {

private Integer idCartao;

private String cor;

private Jogador jogador;

public Pontuacao() {

public Pontuacao(Integer idCartao, String cor) {

super();
[Link] = idCartao;
[Link] = cor;
}

@Override
public String toString() {
return "Pontuacao [idCartao=" + idCartao + ", cor=" +
cor + "]";
}

public Integer getIdCartao() {

[Link] 2
 Apostila Java Básico Aula

Agregação - Cálculo 13
return idCartao;
}
public void setIdCartao(Integer idCartao) {
[Link] = idCartao;
}
public String getCor() {
return cor;
}
public void setCor(String cor) {
[Link] = cor;
}

public Jogador getJogador() {

return jogador;
}

public void setJogador(Jogador jogador) {

[Link] = jogador;
}
}

Criar a classe GerenteProjeto com os atributos(código e nome). Relacionar a

classe GerenteProjeto com a lista de Equipe. Significando que a classe
GerenteProjeto tem uma lista de Equipe. Criar os construtores vazio e cheio,
toString e getters e setters.

package entity;

import [Link];
import [Link];

public class GerenteProjeto {

private Integer codigo;

private String nome;

private List<Equipe> equipes;

public GerenteProjeto() {

[Link] 3
 Apostila Java Básico Aula

Agregação - Cálculo 13
public GerenteProjeto(Integer codigo, String nome,
List<Equipe> equipes) {
[Link] = codigo;
[Link] = nome;
[Link] = equipes;
}

@Override
public String toString() {
return "GerenteProjeto [codigo=" + codigo + ", nome=" +
nome + ", equipes=" + equipes + "]";
}

public Integer getCodigo() {

return codigo;
}
public void setCodigo(Integer codigo) {
[Link] = codigo;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public List<Equipe> getEquipes() {
return equipes;
}

public void add(Equipe e){

if (e==null){
equipes = new ArrayList<Equipe>();
}
[Link](e);
}

Criar a classe Equipe com os atributos (idEquipe e nomeFuncionario).

Relacionar a classe Equipe com a classe GerenteProjeto e o atributo gerente.
Criar os construtores vazio, cheio com todos os atributos e cheio sem o
atributo de gerente. Criar o toString e os getters e setters.

[Link] 4
 Apostila Java Básico Aula

Agregação - Cálculo 13
package entity;

public class Equipe {

private Integer idEquipe;

private String nomeFuncionario;

private GerenteProjeto gerente;

public Equipe() {

public Equipe(Integer idEquipe, String nomeFuncionario,

GerenteProjeto gerente) {
super();
[Link] = idEquipe;
[Link] = nomeFuncionario;
[Link] = gerente;
}

public Equipe(Integer idEquipe, String nomeFuncionario) {

super();
[Link] = idEquipe;
[Link] = nomeFuncionario;
}

@Override
public String toString() {
return "Equipe [idEquipe=" + idEquipe + ",
nomeFuncionario=" + nomeFuncionario + ", gerente=" + gerente +
"]";
}

public Equipe(GerenteProjeto gerente) {

[Link] = gerente;
}
public Integer getIdEquipe() {
return idEquipe;
}
public void setIdEquipe(Integer idEquipe) {
[Link] = idEquipe;

[Link] 5
 Apostila Java Básico Aula

Agregação - Cálculo 13
}
public String getNomeFuncionario() {
return nomeFuncionario;
}
public void setNomeFuncionario(String nomeFuncionario) {
[Link] = nomeFuncionario;
}
public void setGerente(GerenteProjeto gerente) {
[Link] = gerente;
}

No método getGerente, colocamos a condição de que se o gerente for nulo,

o atributo dá um espaço de memória pra o gerente ser criado e retorna esse
gerente.

public GerenteProjeto getGerente() {

if (gerente == null){
gerente = new GerenteProjeto();
}
return gerente;
}

No método de teste, chamamos a classe GerenteProjeto, criamos o objeto e

damos espaço de memória. Em seguida setamos, ou seja, passamos os
dados de código e um nome. Chamamos a classe Equipe e o objeto, setamos
os dados de equipe(código, nome e gerente, se houver). Na impressão,
pediremos para imprimir o nome da equipe e o nome do gerente se houver.

public static void main(String[] args) {

GerenteProjeto gp = new GerenteProjeto();

[Link](1000);
[Link]("stuart");

Equipe e1 = new Equipe(10,"lu",gp);

Equipe e2 = new Equipe(12,"anthony");
Equipe e3 = new Equipe(14,"garrito",gp);

[Link]([Link]() + ", GP=" +

[Link]().getNome());
[Link]([Link]() + ", GP=" +
[Link]().getNome());

[Link] 6
 Apostila Java Básico Aula

Agregação - Cálculo 13
[Link]([Link]() + ", GP=" +
[Link]().getNome());
}
}

No console...

lu, GP=stuart
anthony, GP=null
garrito, GP=stuart

Criar um pacote control e nele criar uma classe CalcularPontuacao para os

cálculos dos pontos dos jogadores.

package control;

import [Link];
import [Link];

public class CalcularPontuacao {

Criar um metodo adicionar, passando como parametro a classe Jogador, a

Pontuacao e uma variável do tipo inteiro chamado pontos. Relacionar o
objeto da classe Jogador, passando o método setPontuacao e parâmetro p.
fazer o mesmo para o inverso, relacionar o objeto p de Pontuacao com j do
Jogador. Sendo um relacionamento bidirecional, as duas classes se vêem.
Chamar o objeto j e setar os Pontos do jogador onde irá somar os pontos já
existentes com os pontos adicionados.

public void adicionar(Jogador j, Pontuacao p, Integer

pontos){
[Link](p);
[Link](j);
[Link]( ([Link]() + pontos) );
}

[Link] 7
 Apostila Java Básico Aula

Agregação - Cálculo 13
No teste main, criar os jogadores com seus dados, criar as pontuações
também com seus dados.

public static void main(String[] args) {

Jogador j1 = new Jogador(10,"leandro",0);
Jogador j2 = new Jogador(11,"noe",0);

Pontuacao p1 = new Pontuacao(1001,"azul");

Pontuacao p2 = new Pontuacao(1002,"vermelho");

Chamar a classe de calculo, CalcularPontuacao, criar objeto e dar espaço de

memória. Passar o objeto com o método adicionar e os parâmetros de
relação: Jogador j1 com cartela de pontuação p1 e quantidade de pontos. Na
impressão, na primeira linha imprimir o nome do jogador e a cartela, na
segunda, a quantidade final de pontos.

CalcularPontuacao cp = new CalcularPontuacao();

[Link](j1, p1, 30);
[Link](j1, p1, 100);
[Link](j2, p2, 50);

[Link]([Link]() + "," +
[Link]().getIdCartao());
[Link]("Pontos :" + [Link]());
[Link]([Link]() + "," +
[Link]().getIdCartao());
[Link]("Pontos :" + [Link]());

}
}

No console...

leandro,1001
Pontos :130
noe,1002
Pontos :50

[Link] 8
 Apostila Java Básico Aula

Mapa 14
Criar um projeto -> Aula14.
Criar no pacote entity as classes Aluno e Endereco. Na classe Aluno
implementar a interface Comparable, criar os atributos (idAluno, nome,
disciplina, nota1,nota2 e media, sendo transient), relacionar com a classe
Endereco. Depois criar os construtores vazio e cheio sem os atributos de
media e relacionamento de Endereço. Colocar o toString e getters e setters.
Inicializar o atributo média com 0 (zero), pois será calculada pelo sistema.

package entity;

import [Link];
import [Link];

public class Aluno implements Comparable<Aluno> {

private Integer idAluno;

private String nome;
private String disciplina;
private Double nota1;
private Double nota2;
private transient Double media = 0.;

private Endereco endereco;

public Aluno() {

public Aluno(Integer idAluno, String nome, String

disciplina, Double nota1, Double nota2) {
super();
[Link] = idAluno;
[Link] = nome;
[Link] = disciplina;
this.nota1 = nota1;
this.nota2 = nota2;
}

@Override
public String toString() {
return "Aluno [idAluno=" + idAluno + ", nome=" + nome +
", disciplina=" + disciplina + ", nota1=" + nota1 + ", nota2=" +
nota2 + ", media=" + media + ", endereco=" + endereco + "]";
}

[Link] 1
 Apostila Java Básico Aula

Mapa 14

public Integer getIdAluno() {

return idAluno;
}
public void setIdAluno(Integer idAluno) {
[Link] = idAluno;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public String getDisciplina() {
return disciplina;
}
public void setDisciplina(String disciplina) {
[Link] = disciplina;
}
public Double getNota1() {
return nota1;
}
public void setNota1(Double nota1) {
this.nota1 = nota1;
}
public Double getNota2() {
return nota2;
}
public void setNota2(Double nota2) {
this.nota2 = nota2;
}
public Double getMedia() {
return media;
}
public void setMedia(Double media) {
[Link] = media;
}
public Endereco getEndereco() {
return endereco;
}
public void setEndereco(Endereco endereco) {
[Link] = endereco;
}

[Link] 2
 Apostila Java Básico Aula

Mapa 14
@Override
public boolean equals(Object obj) {
Aluno a = (Aluno) obj;
return [Link]([Link]());
}

@Override
public int compareTo(Aluno a) {
return [Link]([Link]());
}

@Override
public int hashCode() {
return [Link](idAluno).length();
}

No método main, criar 2 alunos e 2 endereços. Chamando a classe Aluno,

criando o objeto e dando espaço de memória. Fazer o mesmo para a classe
Endereco. Relacionar os objetos de Aluno setando os objetos de Endereco.

public static void main(String[] args) {

Aluno al1 = new Aluno(10,"jose","java",7.,8.);
Aluno al2 = new Aluno(11,"carlos","oracle",9.,8.);

Endereco end1= new Endereco(100,"vila

Emil","Mesquita");
Endereco end2= new Endereco(200,"lapa","RJ");
[Link](end1);
[Link](end2);

Chamar a interface List, passar Aluno como parâmetro e criar o objeto de

lista com o espaço de memória para trabalhar. Chamar o objeto lista e o
método add com o parâmetro do objeto aluno. Pedir para imprimir o aluno
da lista que está na posição 0 (zero). O mesmo com o endereco, irá imprimir
o endereco constante na lista na posição 0 (zero).

List<Aluno> lista = new ArrayList<Aluno>();

[Link](al1);
[Link](al2);
[Link]("Aluno: " + [Link](0));

[Link] 3
 Apostila Java Básico Aula

Mapa 14
[Link]("Resposta: " +
[Link](0).getEndereco());
}
}

No console...

Aluno: Aluno [idAluno=10, nome=jose, disciplina=java, nota1=7.0,

nota2=8.0, media=0.0, endereco=Endereco [idEndereco=100,
bairro=lapa Emil, cidade=Mesquita]]

Resposta: Endereco [idEndereco=100, bairro=lapa Emil,

cidade=Mesquita]

Na classe Endereco criar os atributos (idEndereco,bairro, cidade). Na classe

Endereco relacionar com a classe Aluno, criar o construtor vazio, o cheio
sem o atributo de relacionamento do aluno, toString (sem os dados de
aluno) e os getters e setters.

package entity;

public class Endereco {

private Integer idEndereco;
private String bairro;
private String cidade;

private Aluno aluno;

public Endereco() {

public Endereco(Integer idEndereco, String bairro, String

cidade) {
super();
[Link] = idEndereco;
[Link] = bairro;
[Link] = cidade;
}

[Link] 4
 Apostila Java Básico Aula

Mapa 14

@Override
public String toString() {
return "Endereco [idEndereco=" + idEndereco + ",
bairro=" + bairro + ", cidade=" + cidade + "]";
}

public Integer getIdEndereco() {

return idEndereco;
}
public void setIdEndereco(Integer idEndereco) {
[Link] = idEndereco;
}
public String getBairro() {
return bairro;
}
public void setBairro(String bairro) {
[Link] = bairro;
}
public String getCidade() {
return cidade;
}
public void setCidade(String cidade) {
[Link] = cidade;
}
public Aluno getAluno() {
return aluno;
}
public void setAluno(Aluno aluno) {
[Link] = aluno;
}
}

Criar um pacote chamado mapa e nele criar uma classe chamada Mapa.
Criar um método de teste, main.

package mapa;

import [Link];
import [Link];
import [Link];

[Link] 5
 Apostila Java Básico Aula

Mapa 14
import [Link];

public class Mapa {

public static void main(String[] args) {

Chamar a interface Mapa, tipar os objetos a serem criado como Integer e

String e depois criar o objeto mapa. Dar espaço através do TreeMap,
passando os mesmos tipos. Depois chamar o objeto e o método put, para
inserir os dados no mapa, que são: código e nome.

Map<Integer, String> mapa = new TreeMap<Integer,

String>();
[Link](10, "luis");
[Link](8, "andre");
[Link](12, "lidia");

Criamos um loop de for onde tipamos o objeto chave e chamamos o mapa e

usamos o keySet. Pedimos para imprimir essa chave que virá ordenada.
Depois fazemos o mesmo para imprimirmos a lista dos nomes que também
virá ordenada.

[Link]("Chaves: ");
for (Integer chave : [Link]()){
[Link](chave);
}

[Link]("Nomes: ");
for (String texto : [Link]()){
[Link](texto);
}

Nessa impressão escrevemos um tetxto (“Boolena”) e contacatenamos com

o objeto mapa e o método containsKey onde tipamos para Integer e
verificamos se existe o numero 10 de chave. Esse tipo de método retorna
um booleano (true ou false). Se 10 existir a resposat será verdadeira (true).

[Link]("Booleana :" + [Link](new

Integer(10)));

[Link] 6
 Apostila Java Básico Aula

Mapa 14
Nesse novo teste criamos uma variável de String onde será inciada com o
espaço entre as aspas e uma outra variável Integer com valor “10”. No loop
de for tipamos Integer para a variável “chave” e chamamos o objeto “mapa”
com o método keySet e damos a condição se a variável “chaveproc” for igual
a “chave”, a “chaveproc” recebera o valor de “chave”. A variavel
“procuravalor” receberá do “mapa” na posição da “chave” o valor de String
correspondente. Onde imprimiremos o valor da chave e seu conteúdo,

String procuravalor = "";

Integer chaveproc = 10;

for (Integer chave : [Link]()){

if ([Link](chave)){
chaveproc = chave;
procuravalor = [Link](chaveproc);
}
}
[Link]("Chave=" + chaveproc + ", Conteudo
:" + procuravalor);
Nesse novo teste pela inteface Map passamos as classe Aluno e Endereco
como parâmetros para o objeto “mapa2” e damos espaço com o TreeMap.
Adicionamos em “mapa2”, através do put os dados de Aluno e Endereco.
Pedimos para imprimir esse objeto

Map <Aluno, Endereco> mapa2 = new

TreeMap<Aluno,Endereco>();
[Link](new Aluno(10,"jose","java",10.,6.),
new Endereco(1,"mesquita","mesquita"));
[Link](new Aluno(12,"carlos","ORACLE",9.,9.),
new Endereco(1,"tijuca","rj"));
[Link](mapa2);

Novo teste com a classe Aluno e objeto “busca” dar espaço de memória.
Setar o código do aluno e criar uma condição de que se se no mapa2
contiver o código passado em busca cai no loop do for, onde passo para o
objeto de Aluno a chave keySey de mapa2.

Na condição if, se o resultado da busca for igual ao objeto, passo que busca
recebra a, o objeto, e busca setará o endereço. Senão, se a busca for nula,
vazia, imprime a mensagem.

[Link] 7
 Apostila Java Básico Aula

Mapa 14
Se passar pela condição, imprime o nome do aluno e depois imprime o
endereço.

Aluno busca = new Aluno();

[Link](10);
if ([Link](busca)){
for(Aluno a : [Link]()){
if ([Link](a)){
busca = a;
[Link]([Link](busca));
}
}
}else{
busca=null;
[Link]("Nao encontrado");
}
[Link]("Nome do Aluno :" + [Link]());
[Link]("Dados do Endereco:" +
[Link]());
}
}

No console...

Chaves:
8
10
12

Nomes:
andre
luis
lidia

Booleana :true

Chave=10, Conteudo :Luis

{Aluno [idAluno=10, nome=jose, disciplina=java, nota1=10.0,

nota2=6.0, media=0.0, endereco=null]=Endereco [idEndereco=1,
bairro=mesquita, cidade=mesquita], Aluno [idAluno=12,
nome=carlos, disciplina=ORACLE, nota1=9.0, nota2=9.0, media=0.0,

[Link] 8
 Apostila Java Básico Aula

Mapa 14
endereco=null]=Endereco [idEndereco=1, bairro=tijuca,
cidade=rj]}

Nome do Aluno :jose

Dados do Endereco:Endereco [idEndereco=1, bairro=mesquita,
cidade=mesquita]

[Link] 9
 Apostila Java Básico Aula

Enum 15
A classe enum funciona como uma enumeração de constantes. Essas constantes
podem ter valores associados e funcionam com um vetor, ou seja, cada constante é
uma posição do vetor. Uma característica da classe enum é ter o construtor privado.
Na declaração da classe enum não é criado espaço de memória, logo ela funciona com
uma classe static. A classe static já tem espaço de memória para funcionar.

Enumeração (tipo de dado)

Em programação, uma enumeração é um tipo de dado abstrato, cujos valores são
atribuídos a exatamente um elemento de um conjunto finito de
identificadores escolhidos pelo programador. Esse tipo é geralmente usado
para variáveis categóricas (como os naipes de um baralho), que não possuem uma
ordem numérica definida.
Em tempo de execução, um tipo de dado enumerado é geralmente implementado
usado-se inteiros. Entretanto, comparando-se a usar somente inteiros, os tipos
enumerados tornam o código fonte mais bem documentado que através do uso
explícito de "números mágicos". Dependendo da linguagem, a representação de
inteiro pode não ser visível ao programador, o que previne operações como aritmética
de enumerações.
Em algumas linguagens, o tipo booleano é declarado como uma enumeração de dois
valores, verdadeiro e falso.

package entity;

public enum Bimestre {

//Criando as Constantes
PRIMEIRO(1), SEGUNDO(2), TERCEIRO(3), QUARTO(4);

//Uma variavel para representar o numero associado a Constante

private Integer pos;

private Bimestre() {
}

@Override
public String toString() {
return [Link]();
}

private Bimestre(Integer pos) {

[Link] = pos;

[Link] 1
 Apostila Java Básico Aula

Enum 15
}
public Integer getPos() {
return pos;
}
public void setPos(Integer pos) {
[Link] = pos;
}

public static void main(String[] args) {

for(Bimestre x : [Link]() ){
[Link]("Nome : " + [Link]());
//PRIMEIRO, SEGUNDO, TERCEIRO, QUARTO
[Link]("Posicao :" + [Link]());
// 0 , 1 , 2 , 3
[Link]("Valor : " + [Link]());
// 1 , 2 , 3 , 4
}
}
}

No console...
Nome : PRIMEIRO
Posicao :0
Valor : 1
Nome : SEGUNDO
Posicao :1
Valor : 2
Nome : TERCEIRO
Posicao :2
Valor : 3
Nome : QUARTO
Posicao :3
Valor : 4

[Link] 2
 Apostila Java Básico Aula

Polimorfismo Interface 16
Polimorfismo:
Polimorfismo significa “muitas formas”. Em Orientação a Objetos, o conceito do
polimorfismo é aplicado quando utilizamos o vertbo SER entre pelo menos 2 ou mais
subclasses, podendo ser feito utilizando-se interfaces ou Classes abstratas.

Na programação orientada a objetos, o polimorfismo permite que referências de

tipos de classes mais abstratas representem o comportamento das classes concretas
que referenciam. Assim, é possível tratar vários tipos de maneira homogênea (através
da interface do tipo mais abstrato). O termo polimorfismo é originário do grego e
significa "muitas formas" (poli = muitas, morphos = formas).

O polimorfismo é caracterizado quando duas ou mais classes distintas tem métodos de

mesmo nome, de forma que uma função possa utilizar um objeto de qualquer uma das
classes polimórficas, sem necessidade de tratar de forma diferenciada conforme a
classe do objeto.[1]

Uma das formas de implementar o polimorfismo é através de uma classe abstrata,

cujos métodos são declarados mas não são definidos, e através de classes
que herdam os métodos desta classe abstrata.[2]

Polimorfismo utilizando Interfaces:

A interface é o tipo de programação mais “puro” do Java, pois não programamos o
conteúdo dos métodos de uma interface, apenas sua declaração (assinatura). Toda
interface Java obedece às seguintes regras:

 Todos os métodos de uma interface são implicitamente públicos e abstratos.

 Todos os métodos de uma interface não possuem corpo, apenas assinatura.
 Os Atributos de uma interface são, por definição, constantes, ou seja, possuem
valor final.
 Quando uma Classe implementa uma interface, a Classe deverá forecer corpo
para todos os métodos da interface, exceto se a Classe for abstrata.
 Uma interface pode herdar de outras interfaces.
 Uma classe pode implementar várias interfaces.

Tipos de polimorfismo:
Existem quatro tipos de polimorfismo que a linguagem pode ter (atente para o fato de
que nem toda linguagem orientada a objeto tem implementado todos os tipos de
polimorfismo):

[Link] 1
 Apostila Java Básico Aula

Polimorfismo Interface 16
 Universal
 Inclusão - um ponteiro para classe mãe pode apontar para uma instância de
uma classe filha (exemplo em Java: List lista = new LinkedList(); (tipo de
polimorfismo mais básico que existe)
 Paramétrico - se restringe ao uso de templates (C++, por exemplo) e generics
(C#/Java)

 Ad-Hoc
 Sobrecarga - duas funções/métodos com o mesmo nome mas assinaturas
diferentes
 Coerção - conversão implícita de tipos sobre os parâmetros de uma função

package entity;

public interface Veiculo {

public void setPlaca(String placa);
public String getPlaca();
}

package entity;

public class Carro implements Veiculo{

private Integer idCarro;
private String nome;
private String placa;

public Carro() {

public Carro(Integer idCarro, String nome, String placa) {

[Link] = idCarro;
[Link] = nome;
[Link] = placa;
}

[Link] 2
 Apostila Java Básico Aula

Polimorfismo Interface 16
@Override
public String toString() {
return idCarro + ", " + nome + ", " + placa;
}

public Integer getIdCarro() {

return idCarro;
}
public void setIdCarro(Integer idCarro) {
[Link] = idCarro;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}

@Override
public String getPlaca() {
return placa;
}

@Override
public void setPlaca(String placa) {
[Link] = placa;
}
}

package entity;

public class Moto implements Veiculo{

private Integer idMoto;
private String modelo;
private String placa;

public Moto() {

public Moto(Integer idMoto, String modelo, String placa) {

[Link] 3
 Apostila Java Básico Aula

Polimorfismo Interface 16
[Link] = idMoto;
[Link] = modelo;
[Link] = placa;
}

@Override
public String toString() {
return idMoto + ", " + modelo + ", " + placa;
}

public Integer getIdMoto() {

return idMoto;
}
public void setIdMoto(Integer idMoto) {
[Link] = idMoto;
}
public String getModelo() {
return modelo;
}
public void setModelo(String modelo) {
[Link] = modelo;
}

@Override
public String getPlaca() {
return placa;
}

@Override
public void setPlaca(String placa) {
[Link] = placa;
}

[Link] 4
 Apostila Java Básico Aula

Polimorfismo Interface 16

No modelo podemos dizer que Carro É Veículo e Moto É Veículo, portanto, a

implementação de interface é um relacionamento do tipo É-UM. A Vantagem deste
tipo de abordagem é o uso do Polimorfismo, pois podemos “Transformar” a Interface
Veículo passando para ela uma instância de Carro ou Moto

package main;

import [Link];
import [Link];
import [Link];

public class Main {

public static void main(String[] args) {
//Polimorfismo

Veiculo v1 = new Carro(1, "Ferrari", "ABC-1234");

Veiculo v2 = new Moto(2, "Suzuki", "ABC-4321");

[Link](v1);

[Link] 5
 Apostila Java Básico Aula

Polimorfismo Interface 16
[Link](v2);
}
}

No console...
1, Ferrari, ABC-1234
2, Suzuki, ABC-4321

[Link] 6
 Apostila Java Básico Aula

Polimorfismo Classe Abstrata 17

Polimorfismo:
Polimorfismo significa “muitas formas”. Em Orientação a Objetos, o conceito do
polimorfismo é aplicado quando utilizamos o vertbo SER entre pelo menos 2 ou mais
subclasses, podendo ser feito utilizando-se interfaces ou Classes abstratas.

Na programação orientada a objetos, o polimorfismo permite que referências de

tipos de classes mais abstratas representem o comportamento das classes concretas
que referenciam. Assim, é possível tratar vários tipos de maneira homogênea (através
da interface do tipo mais abstrato). O termo polimorfismo é originário do grego e
significa "muitas formas" (poli = muitas, morphos = formas).

O polimorfismo é caracterizado quando duas ou mais classes distintas tem métodos de

mesmo nome, de forma que uma função possa utilizar um objeto de qualquer uma das
classes polimórficas, sem necessidade de tratar de forma diferenciada conforme a
classe do objeto.[1]

Uma das formas de implementar o polimorfismo é através de uma classe abstrata,

cujos métodos são declarados mas não são definidos, e através de classes
que herdam os métodos desta classe abstrata.[2]

Polimorfismo utilizando Classes Abstratas:

Outra maneira de representarmos o polimorfismo é através do uso de classes
abstratas. Uma Classe abstrata é uma Classe que pode conter atributos, métodos e
construtores como uma Classe comum, mas que também pode ter métodos definidos
como abstratos, similares aos da interface.

Regras sobre classes abstratas:

 Uma Classe abstrata pode conter métodos abstratos.

 Para que possamos declarar um método como abstrato, a Classe deve ser do
tipo abstrata.
 Quando uma Classe comum herda de uma Classe abstrata, ela é obrigada, assim
como no caso da interface, a implementar os métodos.

package entity;

public abstract class Automovel {

private Integer idAutomovel;
private String nome;

[Link] 1
 Apostila Java Básico Aula

Polimorfismo Classe Abstrata 17

public Automovel() {
}

public Automovel(Integer idAutomovel, String nome) {

[Link] = idAutomovel;
[Link] = nome;
}

@Override
public String toString() {
return idAutomovel + ", " + nome;
}

public Integer getIdAutomovel() {

return idAutomovel;
}
public void setIdAutomovel(Integer idAutomovel) {
[Link] = idAutomovel;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}

// Métodos abstratos
public abstract void setFabricante(String fabricante);
public abstract String getFabricante();

package entity;

public class CarroEsportivo extends

Automovel{
private Integer ano;
private String fabricante;

public CarroEsportivo() {

[Link] 2
 Apostila Java Básico Aula

Polimorfismo Classe Abstrata 17

}

public CarroEsportivo(Integer idAutomovel, String nome, Integer

ano, String fabricante) {
super(idAutomovel, nome);
[Link] = ano;
[Link] = fabricante;
}

@Override
public String toString() {
return [Link]() + ", " + ano + ", " + fabricante;
}

public Integer getAno() {

return ano;
}
public void setAno(Integer ano) {
[Link] = ano;
}

@Override
public String getFabricante() {
return fabricante;
}

@Override
public void setFabricante(String fabricante) {
[Link] = fabricante;
}
}

package entity;

public class CarroExecutivo extends

Automovel{
private String modelo;
private String fabricante;

public CarroExecutivo() {

[Link] 3
 Apostila Java Básico Aula

Polimorfismo Classe Abstrata 17

public CarroExecutivo(Integer idAutomovel, String nome, String
modelo, tring fabricante) {
super(idAutomovel, nome);
[Link] = modelo;
[Link] = fabricante;
}

@Override
public String toString() {
return [Link]() + ", " + modelo + ", " + fabricante;
}

public String getModelo() {

return modelo;
}
public void setModelo(String modelo) {
[Link] = modelo;
}

@Override
public String getFabricante() {
return fabricante;
}

@Override
public void setFabricante(String fabricante) {
[Link] = fabricante;
}
}

package main;

import [Link];
import [Link];
import [Link];

public class Main2 {

public static void main(String[] args) {

Automovel a1 = new CarroEsportivo(1, "Ferrari", 2012,

"Ferrari Italia");

[Link] 4
 Apostila Java Básico Aula

Polimorfismo Classe Abstrata 17

Automovel a2 = new CarroExecutivo(2, "C4", "Sedan",
"Citroen");
[Link](a1);
[Link](a2);
}
}

No console...
1, Ferrari, 2012, Ferrari Italia
2, C4, Sedan, Citroen

No exemplo acima podemos dizer que CarroEsportivo É Automovel e CarroExecutivo É

Automovel, portanto, a herança da Classe abstrata configura o uso de Polimorfismo.
Note que Transformamos o objeto Automovel em CarroEsportivo e CarroExecutivo

[Link] 5
 Apostila Java Básico Aula

Classes em OO 18
Orientação a Objetos em Java - Criando Classes:
A Orientação a Objetos é uma maneira alternativa de pensar os problemas de
sistemas de informação utilizando modelos organizados a partir de conceitos do
mundo real. O artefato base é o “objeto” capaz de combinar estrutura e
comportamento em uma única “entidade”. Tudo o que podemos ver no mundo real é
considerado um objeto com atributos e comportamentos definidos. Na qualidade de
método de modelagem, é tida como a melhor estratégia para se eliminar a
dificuldade recorrente no processo de modelar o mundo real do domínio do problema
em um conjunto de componentes de software que seja o mais fiel na sua
representação deste domínio.

A Linguagem Java:
Java é a base de praticamente todos os tipos de aplicativos em rede, e é o padrão
global para desenvolvimento e fornecimento de aplicativos para celular, jogos,
conteúdo on-line e software corporativo. Com mais de 9 milhões de desenvolvedores
em todo o mundo, o Java permite desenvolver e implantar aplicativos e serviços
incríveis de maneira eficiente. Com ferramentas abrangentes, um ecossistema sólido
e um desempenho eficiente, o Java oferece a portabilidade de aplicativos mesmo
entre os ambientes computacionais mais diferentes.

Java Platform, Enterprise Edition (Java EE):

O Java Platform, Enterprise Edition (Java EE) é o padrão do setor para computação
Java empresarial. Utilize o leve Java EE 6 Web Profile para criar aplicativos Web da
próxima geração e a força total da plataforma Java EE 6 para aplicativos
empresariais. Os desenvolvedores aproveitam os ganhos de produtividade com mais
anotações, mais POJOs, pacotes simplificados e menos configurações de XML.

Java Platform, Standard Edition (Java SE):

O Java SE foi projetado para permitir o desenvolvimento de aplicativos seguros,
portáteis e de alto desempenho para a maior variedade possível de plataformas de
computação. Disponibilizando aplicativos em ambientes heterogêneos, as empresas
podem agilizar a produtividade do usuário final, a comunicação e a colaboração—além
de reduzir drasticamente o custo de propriedade de aplicativos tanto de empresas
quanto de clientes.

Java Micro Edition (Java ME):

O Java Platform, Micro Edition (Java ME) é usado por um grande número de
desenvolvedores de telefone celular Java, operadoras e OEMs para criar produtos
telefônicos de destaque ao redor do mundo. A Oracle é líder no oferecimento de

[Link] 1
 Apostila Java Básico Aula

Classes em OO 18
tecnologia para telefone celular encontrada em mais de três bilhões de dispositivos,
por enquanto.

Toda Classe Java é composta de atributos, métodos e construtores. Em Java, todas as

Classes herdam de Object (SuperClasse de todos os objetos do Java).

package entity;

public class Pessoa {

private Integer idPessoa;
private String nome;

public Pessoa() {
}

public Pessoa(Integer idPessoa, String nome) {

[Link] = idPessoa;
[Link] = nome;
}

public Integer getIdPessoa() {

return idPessoa;
}
public void setIdPessoa(Integer idPessoa) {
[Link] = idPessoa;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}

Note que a Classe posui atributos privados e métodos para entrada e saída dos dados
denominados set (entrada) e get (saída). A Classe também possui 2 métodos
Construtores, o primeiro sendo o Construtor default (padrão) da Classe e o segundo
sendo o Construtor que permite a entrada de dados para a Classe. Quando escrevemos
dois métodos com o mesmo nome, porém com entrada de dados diferentes (como no
caso dos construtores), denominados este procedimento de Sobrecarga de Métodos

A Classe Pessoa herda Object.

[Link] 2
 Apostila Java Básico Aula

Classes em OO 18
Em Java, todas as classes por definição são herança de Object. A Classe Object do
Java possui 3 métodos que podemos implementar quando herdamos dela. São eles:

 toString - Método utilizado para retornar uma String que representa os dados
do objeto, como uma “assinatura” do objeto.
 equals - Método utlizado para comparar se dois objetos da mesma Classe são
iguais.
 hashCode - Método utilizado para retornar o endereço de hashCode do objeto
quando este é criado pelo compilador.

Vejamos um exemplo da Classe Pessoa implementando o método toString:

package entity;

public class Pessoa {

private Integer idPessoa;
private String nome;

public Pessoa() {
}

public Pessoa(Integer idPessoa, String nome) {

[Link] = idPessoa;
[Link] = nome;
}

@Override
public String toString() {
return idPessoa + ", " + nome;
}

public Integer getIdPessoa() {

return idPessoa;
}
public void setIdPessoa(Integer idPessoa) {
[Link] = idPessoa;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {

[Link] 3
 Apostila Java Básico Aula

Classes em OO 18
[Link] = nome;
}
}

Executando a Classe Pessoa:

Para executar a classe Pessoa necessitamos de um método main

package entity;

public class Pessoa {

private Integer idPessoa;
private String nome;

public Pessoa() {
}

public Pessoa(Integer idPessoa, String nome) {

[Link] = idPessoa;
[Link] = nome;
}

public String toString() {

return idPessoa + ", " + nome;
}

public Integer getIdPessoa() {

return idPessoa;
}
public void setIdPessoa(Integer idPessoa) {
[Link] = idPessoa;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}

public static void main(String[] args) {

//Criação do objeto pelo Construtor
Pessoa p = new Pessoa(1, "Sergio");

[Link] 4
 Apostila Java Básico Aula

Classes em OO 18
//Impressão do objeto (toString)
[Link]("Dados de Pessoa: " + p);
}
}

No console...
Dados de Pessoa: 1, Sergio

[Link] 5
 Apostila Java Básico Aula

Interface 19
Interface:
A Interface tem como objetivo a padronização de métodos para sua aplicação e o
comando para representar a interface é o implements. Ela não pode ser instanciada e
sim implementada por outra classe, entretanto a classe que a implementa tem que
ser concreta. Uma classe pode implementar varias interfaces. A Interface extends
outra interface e uma classe concreta implements uma ou mais interfaces.

A interface é um recurso muito utilizado em Java, bem como na maioria das

linguagens orientadas a objeto, para “obrigar” a um determinado grupo de classes a
ter métodos ou propriedades em comum para existir em um determinado contexto,
contudo os métodos podem ser implementados em cada classe de uma maneira
diferente. Pode-se dizer, a grosso modo, que uma interface é um contrato que
quando assumido por uma classe deve ser implementado.

Dentro das interfaces existem somente assinaturas de métodos e propriedades,

cabendo à classe que a utilizará realizar a implementação das assinaturas, dando
comportamentos práticos aos métodos.

[Link] 1
 Apostila Java Básico Aula

Interface 19
Interface IConexao

Apresentação nas Classes em Java:

package entity;

public interface IConexao {

public void open() throws Exception;
public void close() throws Exception;

package entity;

public interface IArquivo extends

IConexao{
public void write() throws Exception;

public String read() throws Exception;

package entity;

public class ConexaoBanco implements

IConexao{
@Override
public void open() throws Exception {
[Link]("Abrir Conexao Banco de Dados");
}

@Override
public void close() throws Exception {
[Link]("Fechar Conexao Banco de Dados");
}
}

[Link] 2
 Apostila Java Básico Aula

Interface 19

package entity;

public class ConexaoArquivo implements

IArquivo{
@Override
public void open() throws Exception {
[Link]("Abrir Conexao Arquivo");
}

@Override
public void close() throws Exception {
[Link]("Fechar Conexao Arquivo");
}

@Override
public void write() throws Exception {
[Link]("Escrever no Arquivo");
}

@Override
public String read() throws Exception {
return "Ler do Arquivo";
}

[Link] 3
 Apostila Java Básico Aula

Encapsulamento 20
Encapsulamento:
É um conceito da orientação a objetivo que significa como pode ser feito a entrada e
saída de dados de uma classe. Na Linguagem existem duas formas para isso. A
primeira seria pelos métodos gets ( Saída de Dados ) e sets ( Entrada de Dados ) e a
outra seria pelo construtor cheio ( Entrada de Dados ) e o toString ( Saída de Dados ).
E os atributos da classe sendo private.

package entity;

public class Aluno {

private Integer idAluno;
private String nomeAluno;
private Double nota1;
private Double nota2;

public Aluno() {
}

public Aluno(Integer idAluno, String nomeAluno, Double nota1,

Double nota2) {
super();
[Link] = idAluno;
[Link] = nomeAluno;
this.nota1 = nota1;
this.nota2 = nota2;
}

@Override
public String toString() {

[Link] 1
 Apostila Java Básico Aula

Encapsulamento 20
return "Aluno [idAluno=" + idAluno + ", nomeAluno=" +
nomeAluno + ", nota1=" + nota1 + ", nota2=" + nota2 + "]";
}

public Integer getIdAluno() {

return idAluno;
}
public void setIdAluno(Integer idAluno) {
[Link] = idAluno;
}
public String getNomeAluno() {
return nomeAluno;
}
public void setNomeAluno(String nomeAluno) {
[Link] = nomeAluno;
}
public Double getNota1() {
return nota1;
}
public void setNota1(Double nota1) {
this.nota1 = nota1;
}
public Double getNota2() {
return nota2;
}
public void setNota2(Double nota2) {
this.nota2 = nota2;
}
}

package main;

import [Link];

public class Main {

public static void main(String[] args) {

//O encapsulamento utilizando set e get

Aluno a1 = new Aluno();
[Link](1);
[Link]("luiz");
a1.setNota1(7.);

[Link] 2
 Apostila Java Básico Aula

Encapsulamento 20
a1.setNota2(8.);
[Link]("Nome: " + [Link]() +
"Nota1: " + a1.getNota1() +
"Nota2: " + a1.getNota2()
);

//------------------------------------------------
// O encapsulamento utilizando Construtor cheio e
// toString ( representado pelo objeto )
Aluno a2 = new Aluno(2,"Joao",8.,6.);
[Link]("Dados: " + a2);
}
}

No console..
Nome: luizNota1: 7.0Nota2: 8.0
Dados: Aluno [idAluno=2, nomeAluno=Joao, nota1=8.0, nota2=6.0]

[Link] 3
 Apostila Java Básico Aula

Classe Abstrata 21
Classe Abstrata:

A classe abstrata é definida pelo modificador denominado abstract na assinatura da

classe. Ela pode ter atributos, métodos com corpo , métodos sem corpo utilizando o
modificador abstract, métodos herdados da classe Object e construtores.

Ela não pode ser instanciada , isto é, criar um objeto dela. Logo temos que herda em
outras classes concretas (Subclasse). Os métodos sem corpo obrigatoriamente terá
que ser rescrito na subclasse como ocorre na Interface, e na subclasse utiliza a
palavra extends para herdar a classe abstrata.

Uma classe abstrata é desenvolvida para representar entidades e conceitos abstratos.

A classe abstrata é sempre uma superclasse que não possui instâncias. Ela define um
modelo (template) para uma funcionalidade e fornece uma implementação
incompleta - a parte genérica dessa funcionalidade - que é compartilhada por um
grupo de classes derivadas. Cada uma das classes derivadas completa a funcionalidade
da classe abstrata adicionando um comportamento específico.

Uma classe abstrata normalmente possui métodos abstratos. Esses métodos são
implementados nas suas classes derivadas concretas com o objetivo de definir o
comportamento específico. O método abstrato define apenas a assinatura do método
e, portanto, não contém código.

Por outro lado, as classes concretas implementam todos os seus métodos e permitem
a criação de instâncias. Uma classe concreta não possui métodos abstratos e,
geralmente, quando utilizadas neste contexto, são classes derivadas de uma classe
abstrata.

[Link] 1
 Apostila Java Básico Aula

Classe Abstrata 21

package entity;

public abstract class Funcionario {

private String nome;
private Double salario;

public Funcionario() {
}

public Funcionario(String nome, Double salario) {

super();
[Link] = nome;
[Link] = salario;
}

@Override
public String toString() {
return "Funcionario [nome=" + nome + ", salario=" + salario
+ "]";
}

[Link] 2
 Apostila Java Básico Aula

Classe Abstrata 21
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public Double getSalario() {
return salario;
}
public void setSalario(Double salario) {
[Link] = salario;
}

public void calculoBonus(Double bonus){

setSalario(getSalario() + bonus);
}

public abstract void calculoDesconto();

}

package entity;

public class FuncionarioCLT extends

Funcionario{
@Override
public void calculoDesconto() {
setSalario(getSalario() - ( (getSalario() * 5 ) / 100 ) );
}
}

package main;

import [Link];

public class Main2 {

public static void main(String[] args) {

FuncionarioCLT fc = new FuncionarioCLT();

[Link] 3
 Apostila Java Básico Aula

Classe Abstrata 21
[Link]("Jose");
[Link](5000.);

[Link]("Nome " + [Link]());

[Link]("Salario Bruto : " + [Link]());

[Link](100.);
[Link]("Salário com Bonus : " +
[Link]());

[Link]();
[Link]("Salário com Desconto : " +
[Link]());
}
}

No console...
Nome 5000.0
Salario Bruto : 5000.0
Salário com Bonus : 5100.0
Salário com Desconto : 4845.0

[Link] 4
 Apostila Java Básico Aula

Equals, Comparable 22
Equals:
O método equals é usado em uma classe para criar um critério de igualdade de dois
ou mais objetos dessa classe. Esse critério pode ser feito por um atributo ou mais.
Esse método é herdado da classe Object. Sem reprogramar esse método o critério de
igualdade do Java é feito pela atribuição de um objeto com o outro. Fazendo isso o
critério de igualdade é feito pela posição de memória dos objetos.

Apresentação nas Classes em Java

Apresentação das classes utilizando o método equals e criando o critério de igualdade

pelo código.

package entity;

public class Pessoa {

private Integer codigo;
private String nome;

public Pessoa() {
}

public Pessoa(Integer codigo, String nome) {

super();
[Link] = codigo;
[Link] = nome;
}

@Override
public String toString() {
return "Pessoa [codigo=" + codigo + ", nome=" + nome + "]";
}

@Override
public boolean equals(Object obj) {
Pessoa p = (Pessoa) obj;
// Essa linha faz um conversão de Object para Pessoa.
return [Link]([Link]());
// Criando o critério de igualdade
}

public Integer getCodigo() {

return codigo;

[Link] 1
 Apostila Java Básico Aula

Equals, Comparable 22
}
public void setCodigo(Integer codigo) {
[Link] = codigo;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
}

package main;

import [Link];

public class Main3 {

public static void main(String[] args) {

Pessoa p = new Pessoa(1,"joao");

Pessoa p1 = new Pessoa(1,"joao");

// A resposta dessa comparação é true

// Porque foi reprogramado o método equals
[Link]([Link](p1));
}
}

No console...
true

[Link] 2
 Apostila Java Básico Aula

Equals, Comparable 22
Comparable:
Interface Comparable é usada em uma classe para criar um critério de ordenação. Ao
implementar essa interface tem que reprogramar o método compareTo. Nesse método
é feito o critério podendo ser utilizando um atributo ou mais da classe.

package entity;

public class Pessoa implements

Comparable<Pessoa>{
private Integer codigo;
private String nome;

public Pessoa() {
}

public Pessoa(Integer codigo, String nome) {

super();
[Link] = codigo;
[Link] = nome;
}

@Override
public String toString() {
return "Pessoa [codigo=" + codigo + ", nome=" + nome + "]";
}

@Override
public boolean equals(Object obj) {
Pessoa p = (Pessoa) obj;
// Essa linha faz um conversão de Object para Pessoa.
return [Link]([Link]());
// Criando o critério de igualdade
}

public Integer getCodigo() {

return codigo;
}
public void setCodigo(Integer codigo) {
[Link] = codigo;
}
public String getNome() {

[Link] 3
 Apostila Java Básico Aula

Equals, Comparable 22
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}

@Override
public int compareTo(Pessoa obj) {
// Utilizando a forma abaixo, a ordenação será crescente
return [Link](((Pessoa)obj).getCodigo());
// Utilizando a forma abaixo, a ordenação será decrescente
// return (((Pessoa)obj).getCodigo()).compareTo([Link]);
}
}

package main;

import [Link];
import [Link];
import [Link];

import [Link];

public class Main4 {

public static void main(String[] args) {

Pessoa p1 = new Pessoa(2,"joao");

Pessoa p2 = new Pessoa(1,"joao");
Pessoa p3 = new Pessoa(3,"maria");
// Criar uma lista de Pessoas
List lista = new ArrayList<>();
[Link](p1);
[Link](p2);
[Link](p3);

// Comando para ordenar a lista

// pelo critério feito na classe pessoa
[Link](lista);
[Link](lista);
}
}

[Link] 4
 Apostila Java Básico Aula

Equals, Comparable 22

No console...
[Pessoa [codigo=1, nome=joao], Pessoa [codigo=2, nome=joao], Pessoa
[codigo=3, nome=maria]]

[Link] 5
 Apostila Java Básico Aula

Sobrescrita / Sobrecarga 23
Sobrescrita de Métodos:
A sobrescrita de métodos ocorre quando tem uma subclasse herdado uma classe ou
implementado uma interface. Esse método caracteriza-se pela assinatura do método
ser igual ao método da Superclasse ou da Interface ou pela anotação @Override
(Sobrescrita) acima do método.

Casos que pode ser identificado à sobrescrita.

Quando uma classe herda a classe Object.

package entity;

public class Cliente {

private Integer idCliente;

private String nome;

@Override
public String toString() {
return "Cliente [idCliente=" + idCliente + ", nome=" + nome +
"]";
}

public Integer getIdCliente() {

return idCliente;
}
public void setIdCliente(Integer idCliente) {
[Link] = idCliente;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
}

[Link] 1
 Apostila Java Básico Aula

Sobrescrita / Sobrecarga 23
Quando uma Subclasse herda uma Superclasse.

Nesse caso está sendo sobrescrito o método imprimirDescricao do Funcionario e

reescrito no FuncionarioCLT.

package entity;

public class Funcionario {

private Integer idFuncionario;
private String nome;
private String descricao;

public Funcionario() {
}

public Funcionario(Integer idFuncionario, String nome, String

descricao) {
super();
[Link] = idFuncionario;
[Link] = nome;
[Link] = descricao;
}

@Override
public String toString() {
return "Funcionario [idFuncionario=" + idFuncionario + ",
nome=" + nome + ", descricao=" + descricao + "]";
}

public Integer getIdFuncionario() {

return idFuncionario;
}
public void setIdFuncionario(Integer idFuncionario) {
[Link] = idFuncionario;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public String getDescricao() {

[Link] 2
 Apostila Java Básico Aula

Sobrescrita / Sobrecarga 23
return descricao;
}
public void setDescricao(String descricao) {
[Link] = descricao;
}
public String imprimirDescricao(){
return "Funcionario Padrao";
}
}

package entity;

public class FuncionarioCLT extends

Funcionario{
public FuncionarioCLT() {

public FuncionarioCLT(Integer idFuncionario, String nome, String

descricao) {
super(idFuncionario, nome, descricao);
}

@Override
public String imprimirDescricao() {
return "Funcionario CLT";
}
}

package main;

import [Link];
import [Link];

public class Main {

public static void main(String[] args) {

[Link] 3
 Apostila Java Básico Aula

Sobrescrita / Sobrecarga 23
Funcionario f = new Funcionario(100, "jose", "funcionario");

[Link]("Funcionario: " + f + "\n Descricao: " +

[Link]());

FuncionarioCLT f1 = new FuncionarioCLT(2, "Luiz",

"gerente");
[Link]("\nFuncionario: " + f1 + "\n Descricao: "
+ [Link]());
}
}

No console...
Funcionario: Funcionario [idFuncionario=100, nome=jose,
descricao=funcionario]
Descricao: Funcionario Padrao

Funcionario: Funcionario [idFuncionario=2, nome=Luiz,

descricao=gerente]
Descricao: Funcionario CLT

Quando uma classe implementa uma Interface.

package entity;

public interface IArquivo {

public void open() throws Exception;
public void close() throws Exception;

[Link] 4
 Apostila Java Básico Aula

Sobrescrita / Sobrecarga 23
package entity;

public class Arquivo implements IArquivo{

@Override
public void open() throws Exception {
[Link]("Abrir o Arquivo");
}

@Override
public void close() throws Exception {
[Link]("Fechar o Arquivo");
}
}

package main;

import [Link];

public class Main2 {

public static void main(String[] args) {

Arquivo a = new Arquivo();

try {
[Link]();
[Link]();
} catch (Exception e) {
[Link]("Error" + [Link]());
}
}
}

No console...
Abrir o Arquivo
Fechar o Arquivo

[Link] 5
 Apostila Java Básico Aula

Sobrescrita / Sobrecarga 23
Sobrecarga de Métodos:
A sobrecarga de métodos ocorre quando tem dois ou mais métodos que possuem a
mesma assinatura e só mudando o tipo ou a quantidades de parâmetros declarados
nele.

Casos que pode ser identificado à sobrecarga:

Quando declaramos dois ou mais construtores na classe

package entity;

public class Cliente {

private Integer idCliente;
private String nome;

public Cliente() {

@Override
public String toString() {
return "Cliente [idCliente=" + idCliente + ", nome=" + nome +
"]";
}

public Integer getIdCliente() {

return idCliente;
}
public void setIdCliente(Integer idCliente) {
[Link] = idCliente;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
}

[Link] 6
 Apostila Java Básico Aula

Sobrescrita / Sobrecarga 23
Quando ocorre é declarado dois ou mais métodos na mesma classe.

A assinatura: public void print Os parametros: int a ; double a ; int a , int b

package entity;

public class Numero {

public void print(int a){
[Link]("Numero" + a);
}

public void print(int a, int b){

[Link]("Numero" + a);
}

public void print(double a){

[Link]("Numero" + a);
}
}

Nesse caso ocorre quando herda uma Superclasse

package entity;

public class NumeroNatural extends Numero{

public void print(int a, int b, int c ){
[Link]("Numeros" + a + b + c);
}
}

[Link] 7
 Apostila Java Básico Aula

Sobrescrita / Sobrecarga 23
package main;

import [Link];

public class Main3 {

public static void main(String[] args) {

NumeroNatural nn = new NumeroNatural();

//Metodos da SuperClasse Numero

[Link](1);
[Link](2.);
[Link](3, 4);

//Metodo da SubClasse NumeroNatural

[Link](3, 5, 4);
}
}

No console...
Numero1
Numero2.0
Numero3
Numeros354

[Link] 8
 Apostila Java Básico Aula

Tratamento de Erro 24
Tratamento de Erro:
O tratamento de erros na linguagem Java é feito pelo uso dos comandos try, catch,
finally. E tem outros dois comandos que são: throw e o throws. No Java existe a classe
Throwable que é a superclasse de todas as exceções , e tem dois ramos um das
Exception ( que são exceções , por exemplo , divisão por zero ) e o outro ramo dos
Error ( que são erros que não poderia ocorrer , por exemplo, estouro de memória).

Comando Try:

Esse comando tem como finalidade de tentativa de executar alguma ação, exemplo
gravação de dados em arquivo.

Comando Catch:

Esse comando tem como finalidade de gerar a mensagem de erro e evitar que o
programa pare.

Comando Finally:

Esse comando sempre executa mesmo ocorrendo uma erro no projeto.

A código abaixo apresenta o erro na tentativa de dividir um numero por zero e assim
parando o projeto.

[Link] 1
 Apostila Java Básico Aula

Tratamento de Erro 24
package entity;

public class Numero {

private Integer num1;
private Integer num2;

public Numero() {
}

public Numero(Integer num1, Integer num2) {

super();
this.num1 = num1;
this.num2 = num2;
}

@Override
public String toString() {
return "Numero [num1=" + num1 + ", num2=" + num2 + "]";
}

public Integer getNum1() {

return num1;
}
public void setNum1(Integer num1) {
this.num1 = num1;
}
public Integer getNum2() {
return num2;
}
public void setNum2(Integer num2) {
this.num2 = num2;
}
}

Agora será utilizado o bloco de instrução try, catch e finally para evitar que o projeto
pare.
Executando o CRUD no main

Comando throw

O comando throw serve para gerar uma exceção no java . Ele é usado para validar
alguma ação e enviar uma mensagem para o usuário, utilizando o catch.

[Link] 2
 Apostila Java Básico Aula

Tratamento de Erro 24
package main;

import [Link];

public class Main {

public static void main(String[] args) {

//Instacia a classe Numero

Numero n = new Numero(10, 0);
int resp;

try {
// Serve para validar se o numero2 e menor ou igual a 0
// Se for envia uma mensagem para o catch.
if(n.getNum2() <= 0){
throw new Exception("Numero 2 não pode ser zero ou menor");
}

//Faz o calculo
resp = n.getNum1() / n.getNum2();

//Apresenta o Resultado
[Link](resp);
} catch (Exception e) {
// Apresenta o Erro by /zero no entanto , o projeto continua
funcionando
// Até o último comando.
[Link]("Error: " + [Link]());
}
finally{
[Link]("Sempre executa o finally \n ");
}
[Link]("continua");
}
}

No console...
Error: Numero 2 não pode ser zero ou menor
Sempre executa o finally

Continua

[Link] 3
 Apostila Java Básico Aula

Padrão MVC 25
MVC:
Um diagrama simples exemplificando a relação entre Model, View e
Controller. As linhas sólidas indicam associação direta e as tracejadas indicam
associação indireta.
Model-view-controller (MVC), em português modelo-visão-controlador, é um
padrão de arquitetura de software (design pattern) que separa a
representação da informação da interação do usuário com ele.
O modelo (model) consiste nos dados da aplicação, regras de negócios, lógica
e funções. Uma visão (view) pode ser qualquer saída de representação dos
dados, como uma tabela ou um diagrama. É possível ter várias visões do
mesmo dado, como um gráfico de barras para gerenciamento e uma visão
tabular para contadores. Ocontrolador (controller) faz a mediação da
entrada, convertendo-a em comandos para o modelo ou visão. As ideias
centrais por trás do MVC são a reusabilidade de código e separação de
conceitos.

Esse padrão tem a finalidade de dividir o projeto em três camadas:

1- Camada Modelo: A camada Modelo tem as classes de dados que define o

domínio da aplicação, por exemplo, classe aluno, professor, turma se sua
aplicação for de controle de turma.
2- Camada View: A camada View corresponde a qualquer entrada de dados da
aplicação, por exemplo, leitura de dados pelo console, paginas jsp, xhtml
entre outras.
3- Camada Control: A camada control corresponde à regra de negocio da
aplicação e centralizando as informações vindas da camada view, passando
para camada de modelo e voltando para camada de view.

[Link] 1
 Apostila Java Básico Aula

Padrão MVC 25
Uso em aplicações web :
Apesar de desenvolvida originalmente para computação pessoal, o MVC foi
amplamente adaptado como uma arquitetura para as aplicações World Wide
Web em todas as linguagens de programação maiores. Muitos frameworks de
aplicação comerciais e não comerciais foram criados tendo como base esse
modelo. Estes frameworks variam em suas interpretações, principalmente no
modo que as responsabilidades MVC são divididas entre o cliente e servidor.

Os frameworks web MVC mais recentes levam uma abordagem de thin

client que colocou quase o modelo, a visão e a lógica do controlador inteiros
no servidor. Nesta abordagem, o cliente envia requisições de hiperlink ou
entrada de formulário ao controlador e então recebe uma página web
completa e atualizada (ou outro documento) da visão. O modelo existe
inteiramente no servidor. Como as tecnologias de cliente amadureceram,
frameworks como JavaScriptMVC e Backbone foram criados o que permite que
os componentes MVC executem parcialmente no cliente (ver também AJAX).

Um caso prático é uma aplicação web em que a visão é um documento HTML

(ou derivado) gerado pela aplicação. O controlador recebe uma
entrada GET ou POST após um estímulo do utilizador e decide como
processá-la, invocando objetos do domínio para tratar a lógica de negócio, e
por fim invocando uma visão para apresentar a saída

Com o aumento da complexidade das aplicações desenvolvidas, sempre

visando a programação orientada a objeto, torna-se relevante a separação
entre os dados e a apresentação das aplicações. Desta forma, alterações
feitas no layout não afetam a manipulação de dados, e estes poderão ser
reorganizados sem alterar o layout.

Esse padrão resolve este problema através da separação das tarefas de acesso
aos dados e lógica de negócio, lógica de apresentação e de interação com o
utilizador, introduzindo um componente entre os dois: o controlador.

[Link] 2
 Apostila Java Básico Aula

Padrão MVC 25
package entity;

public class Pessoa {

private Integer idPessoa;
private String nome;
private Integer idade;

public Pessoa() {
}

public Pessoa(Integer idPessoa, String nome, Integer idade)

{
super();
[Link] = idPessoa;
[Link] = nome;
[Link] = idade;
}

@Override
public String toString() {
return "Pessoa [idPessoa=" + idPessoa + ", nome=" +
nome + ", idade=" + idade + "]";
}

public Integer getIdPessoa() {

return idPessoa;
}
public void setIdPessoa(Integer idPessoa) {
[Link] = idPessoa;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public Integer getIdade() {
return idade;
}
public void setIdade(Integer idade) {
[Link] = idade;
}

[Link] 3
 Apostila Java Básico Aula

Padrão MVC 25
}

package control;

import [Link];
import [Link];

import [Link];

public class ValidaPessoa {

public void validaCodigo(Pessoa p)throws Exception{
if ([Link]()<=0){
throw new Exception("Codigo Menor ou igual a
zero invalido ...");
}
}

public void validaIdade(Pessoa p)throws Exception{

if ([Link]()<18){
throw new Exception("So pode ser cadastrado
maior de idade");
}
}

public void validaNome(Pessoa p)throws Exception{

Pattern pa = [Link]("[A-Z a-z]{3,35}");
Matcher ma = [Link]([Link]());
if (! [Link]()){
throw new Exception("Nome somente com Letras
faixa (3,35)");
}//se for falso lança o erro
}
}

[Link] 4
 Apostila Java Básico Aula

Padrão MVC 25
package view;

import [Link];

public class InputPessoa {

public Integer lerCodigo() {
try {
[Link]("Digite o Codigo :");
Scanner in = new Scanner([Link]);
return [Link]();
} catch (Exception ex) {
[Link]("Digite numero inteiro ...");
return lerCodigo();
}
}

public Integer lerIdade() {

try {
[Link]("Digite a Idade :");
Scanner in = new Scanner([Link]);
return [Link]();
} catch (Exception ex) {
[Link]("Digite idade inteira ...");
return lerIdade();
}
}

public String lerNome() {

[Link]("Digite o Nome :");
Scanner in = new Scanner([Link]);
return [Link]();
}
}

package main;

import [Link];
import [Link];
import [Link];

[Link] 5
 Apostila Java Básico Aula

Padrão MVC 25
public class Main {
public static void main(String[] args) {
Pessoa p = new Pessoa();
InputPessoa ip = new InputPessoa();
ValidaPessoa vp = new ValidaPessoa();

try{
[Link]([Link]());
[Link]([Link]());
[Link]([Link]());
[Link](p);
[Link](p);
[Link](p);

[Link]("Dados" + p);
}catch(Exception ex){
[Link]("Error" + [Link]());
}
}

No console...
Digite o Codigo :
5
Digite o Nome :
luciana
Digite a Idade :
22
DadosPessoa [idPessoa=5, nome=luciana, idade=22]

[Link] 6
 Apostila Java Básico Aula

Gravação e Leitura de XML 26

Representação da Interface:
Um exemplo de leitura e escrita de arquivo utilizando um conceito
denominado generics e utilizando também o conceito de interface. O Generics
é usado para criar uma classe genérica com o objetivo de passar um
parâmetro que representa a classe que irá herda a classe genérica. A classe
genérica tem a seguinte configuração e o paramento T entre "< >" representa
a subclasse.

package control;

import [Link];

public interface IArquivo {

public void openWrite() throws Exception;
public void closeWrite() throws Exception;
public void write(T obj) throws Exception;

public void openRead() throws Exception;

public void closeRead() throws Exception;
public List read() throws Exception;
}

package entity;

public class Pessoa {

private Integer idPessoa;
private String nome;
private String email;

public Pessoa() {
// TODO Auto-generated constructor stub
}

public Pessoa(Integer idPessoa, String nome, String email)

{
super();
[Link] = idPessoa;

[Link] 1
 Apostila Java Básico Aula

Gravação e Leitura de XML 26

[Link] = nome;
[Link] = email;
}

@Override
public String toString() {
// Modifica o toString para o separador de campo ser ";"
// E assim dividir no array.
return idPessoa + ";" + nome + ";" + email;
}

public Integer getIdPessoa() {

return idPessoa;
}
public void setIdPessoa(Integer idPessoa) {
[Link] = idPessoa;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public String getEmail() {
return email;
}

public void setEmail(String email) {

[Link] = email;
}
}

package control;

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];

[Link] 2
 Apostila Java Básico Aula

Gravação e Leitura de XML 26

public class Arquivo implements
IArquivo{
FileWriter fw;
FileReader fr;
BufferedReader br;

@Override
public void openWrite() throws Exception {
//Nome do diretorio escolhido
File f = new File("c:/temp");
// Cria o diretorio, caso não exista
[Link]();
//Nome do arquivo
File arquivo = new File(f, "[Link]");
//Aponta para o nome do arquivo
fw = new FileWriter(arquivo, true);
}

@Override
public void closeWrite() throws Exception {
[Link](); // Fechar o arquivo
}

@Override
public void write(Pessoa p) throws Exception {
//Escreve no arquivo
[Link]([Link]() + "\n" );
//Atualiza o arquivo
[Link]();
}

@Override
public void openRead() throws Exception {
//Aponta para o arquivo a ser lido
fr = new FileReader("c:/temp/[Link]");
//Colocar os dados no buffer
br = new BufferedReader(fr);
}

@Override
public void closeRead() throws Exception {
[Link](); // fechar o buffer

[Link] 3
 Apostila Java Básico Aula

Gravação e Leitura de XML 26

[Link](); // fechar o arquivo
}

@Override
public List read() throws Exception {

// Representa cada linha do arquivo

String linha = null;
List lista = new ArrayList();

while((linha = [Link]()) != null){

//Separando os campos por virgula e colocando
//em uma posição do array, começando da posição
0
String token[] = [Link](";");

Pessoa p = new Pessoa();

//Adiciona cada posição do vetor
// em seu respectivo atributo da classe Pessoa
[Link](new Integer(token[0]));
[Link](token[1]);
[Link](token[2]);
//Adicionar o objeto de pessoa na lista
[Link](p);
}
return lista;
}
}

package main;

import [Link];
import [Link];

public class Main {

public static void main(String[] args) {

Pessoa p1 = new Pessoa(1, "luiz", "luiz@[Link]");

Pessoa p2 = new Pessoa(2, "jose", "jose@[Link]");

Arquivo a = new Arquivo();

[Link] 4
 Apostila Java Básico Aula

Gravação e Leitura de XML 26

try {

//Abre o Arquivo para Escrita

[Link]();

//Gravar os objetos p1 e p2
[Link](p1);
[Link](p2);

//Fechar o Arquivo para Escrita

[Link]();

[Link]("Dados Gravados");

//Abre o Arquivo para Leitura

[Link]();

//Leitura de cada linha do Arquivo

for(Pessoa p : [Link]()){
[Link]("Dados de Pessoa: " + p
);
}
//Fechar o Arquivo para Leitura
[Link]();

} catch (Exception e) {
[Link]("Error: " + [Link]());
}
}

[Link] 5
 Apostila Java Básico Aula

Padrão DAO 27
DAO - Objeto de acesso a dados:

Esse padrão tem por finalidade criar uma camada de acesso ao banco de
dados e proporcionando o isolamento da camada de persistência das demais
camadas do projeto. Essa camada e composta pela classe DAO e a classe que
terá os métodos para o CRUD (Inserir, Deletar, Excluir e Lista) para cada
entidade da camada de modelo. No exemplo abaixo a classe PessoaDao
representa essa lógica e a entidade a ser persistida no banco de dados é
Pessoa. A classe Dao é composta por dois métodos que são: Open() para abrir
o banco e o Close() para fechar o banco. E alguns atributos como Connection
(Conexão ao Banco de Dados), PreparedStatement (Acessar a Tabela),
ResultSet (Consulta a Tabela) e o CallaBleStatement (Usar Procedures e
Function).

Objeto de acesso a dados (ou simplesmente DAO, acrônimo de Data Access

Object), é um padrão para persistência de dados que permite separar regras
de negócio das regras de acesso a banco de dados. Numa aplicação que utilize
a arquitetura MVC, todas as funcionalidades de bancos de dados, tais como
obter as conexões, mapear objetosJava para tipos de dados SQL ou executar
comandos SQL, devem ser feitas por classes DAO.

Objeto de acesso a dados (ou simplesmente DAO, acrônimo de Data Access

Object), é um padrão para persistência de dados que permite separar regras
de negócio das regras de acesso a banco de dados. Numa aplicação que utilize
a arquitetura MVC, todas as funcionalidades de bancos de dados, tais como
obter as conexões, mapear objetosJava para tipos de dados SQL ou executar
comandos SQL, devem ser feitas por classes DAO.

package entity;

public class Pessoa {

private Integer idPessoa;
private String nomePessoa;
private String email;

public Pessoa() {
}

public Pessoa(String nomePessoa, String email) {

super();
[Link] = nomePessoa;
[Link] = email;
}

[Link] 1
 Apostila Java Básico Aula

Padrão DAO 27
public Pessoa(Integer idPessoa, String nomePessoa, String
email) {
super();
[Link] = idPessoa;
[Link] = nomePessoa;
[Link] = email;
}

@Override
public String toString() {
return "Pessoa [idPessoa=" + idPessoa + ",
nomePessoa=" + nomePessoa + ", email=" + email + "]";
}

public Integer getIdPessoa() {

return idPessoa;
}
public void setIdPessoa(Integer idPessoa) {
[Link] = idPessoa;
}
public String getNomePessoa() {
return nomePessoa;
}
public void setNomePessoa(String nomePessoa) {
[Link] = nomePessoa;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
[Link] = email;
}
}

package persistence;

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

[Link] 2
 Apostila Java Básico Aula

Padrão DAO 27
public class Dao {
Connection con;
// Conexao ao Banco de Dados
PreparedStatement stmt;
// Acessa a Tabela ( insert, update, delete , select)
ResultSet rs;
// Consulta a Tabela( select )
CallableStatement call;
// Procedures e Function

public void open() throws Exception{

[Link]("[Link]");
con = [Link]("caminho",
"usuario", "senha");
}

public void close() throws Exception{

[Link]();
}
}

O comando [Link]() é o caminho do driver de comunicação jdbc com o

banco de dados. Cada banco de dados tem o seu driver.

A primeira String do comando [Link]() representa o

caminho do banco de dados, que nesse exemplo do mysql é
jdbc:mysql://localhost:3306/banco. A palavra banco no caminho ao lado tem
referencia ao banco de dados criado no mysql.

A segunda String do comando representa o usuário que irá acessar o banco de

dados.

A terceira String do comando representa a senha de acesso ao banco de dados

do usuário escolhido. Após definir a classe de conexão do Banco de Dados, o
passo seguinte é definir a classe que irá fazer a lógica do CRUD (Inserir,
Listar, Atualizar, Deletar). Nesse caso será utilizado a classe PessoaDao para
representar essa lógica e nessa classe é herdado a classe Dao.

Exemplo de classe com o CRUD – PessoaDao

[Link] 3
 Apostila Java Básico Aula

Padrão DAO 27
package persistence;

import [Link];
import [Link];

import [Link];

public class PessoaDao extends Dao{

public void create(Pessoa p) throws Exception {
open();
stmt = [Link]("insert into pessoa
values(null,?,?)");
[Link](1, [Link]());
[Link](2, [Link]());
[Link]();
[Link]();
close();
}

public void delete(Pessoa p) throws Exception {

open();
stmt = [Link]("delete from Pessoa where
idPessoa = ?");
[Link](1, [Link]());
[Link]();
[Link]();
close();
}

public void update(Pessoa p) throws Exception {

open();
stmt = [Link]("update Pessoa nome = ?,
email = ? where idPessoa = ?");
[Link](1, [Link]());
[Link](2, [Link]());
[Link](3, [Link]());
[Link]();
[Link]();
close();

[Link] 4
 Apostila Java Básico Aula

Padrão DAO 27
public Pessoa finallByCod(int cod) throws Exception {
open();
stmt = [Link]("select * from
pessoa where idPessoa = ? ");
rs = [Link]();
Pessoa p = null;
if ([Link]()) {
p = new Pessoa();
[Link]([Link]("idPessoa"));
[Link]([Link]("nome"));
[Link]([Link]("email"));
}
close();
return p;
}

public List findAll() {

try {
open();
stmt = [Link]("select * from pessoa");
rs = [Link]();
List lista = new ArrayList();
while ([Link]()) {
Pessoa p = new Pessoa();
[Link]([Link]("idPessoa"));
[Link]([Link]("nomePessoa"));
[Link]([Link]("email"));
[Link](p);
}
close();
return lista;
} catch (Exception e) {
[Link]([Link]());
return null;
}
}
}

Para efetuar um teste com a lógica do CRUD tem que criar o banco e a tabela
pessoa pelo SQL, que é a linguagem padronizada para todos os bancos de
dados, e copiar no mysql. Logo é criado um arquivo chamando [Link].

[Link] 5
 Apostila Java Básico Aula

Padrão DAO 27
[Link]
# O símbolo # serve para comentar no [Link]

# Comando usado para apagar o banco

# Não utilizado em ambiente de construção de sistemas
drop database if exists aula;

# Comando usado para criar o banco

create database aula;

# Comando usado para acessar o banco

use aula;

# Comando para drop a tabela;

drop table pessoa;

# comando para criar uma tabela

create table pessoa(
idPessoa int primary key auto_increment,
nomePessoa varchar(50),
email varchar(50)
);

package main;

import [Link];
import [Link];

public class Main {

public static void main(String[] args) {

//Para testar a Lógica do CRUD

//A chave primaria é null porque no banco de dados está auto
increment
//Quer dizer, chave primaria está sendo incrementa pelo banco.

Pessoa p1 = new Pessoa(null, "jose", "jose@[Link]");

Pessoa p2 = new Pessoa(null, "joao", "joao@[Link]");
PessoaDao pd = new PessoaDao();
try {

[Link] 6
 Apostila Java Básico Aula

Padrão DAO 27
//Comando para gravar no banco;
[Link](p1);
[Link](p2);
//Comando para listaTodos
[Link]([Link]());
//Comando para alterar uma pessoa;
// 1º Passo
//Busca pelo Codigo
// 2 -> é a chave primaria de pessoa no banco
Pessoa pessoa = [Link](2);

[Link]("pessoa:" + pessoa);
[Link]("joao2@[Link]");
// 2º Passo
//Alterar o usuario 2
[Link]("pessoa:" + pessoa);
[Link](pessoa);
//Comando para listaTodos e verificar a alteração
//Varrendo a lista vinda do findAll
//e imprimindo cada linha
//Classe objeto : lista de valores
for(Pessoa p : [Link]()){
[Link](p);
}

//Comando para deletar uma pessoa;

//1º Passo : buscar o Codigo
Pessoa pessoa1 = [Link](2);
//2º Passo
[Link](pessoa1);

//Comando para listaTodos

[Link]([Link]());
} catch (Exception e) {
[Link]("Error: " + [Link]());
}
}
}

[Link] 7
 Apostila Java Básico Aula

CRUD com JSP 28

Um exemplo utilizando o padrão DAO e o padrão MVC. Visto que o padrão DAO
esta representada na camada de persistência (pacote persitence) e o padrão
MVC:

A camada model está representada no pacote entity.

A camada view está representada nas paginas jsp’s.

A camada control está divida no pacote manager (que controla a parte de

consulta ao banco de dados) e o pacote control (que tem uma classe Servlet
onde fará toda a lógica de inserir, deletar e atualizar). O Servlet tem a função
de receber as requisições das paginas jsps, enviar essas requisições para a
camada de persistência, modelo e camada de controle por exemplo, validação
dos campos do formulário jsp, e transmitir os resultados as paginas jsps.

O scriptlet corresponde em atribuir código Java entre <% %> nas paginas jsp’s.
Nesse exemplo é utilizado o JSTL (JSP Standard Tag Library) que é uma
coleção de bibliotecas em Java que permite substituir o scriplet na pagina JSP
por tags JSTLs. Porque cada tag tem uma finalidade bem definida sendo
equivalente a programação Java nas paginas JSPs.

[Link] 1
 Apostila Java Básico Aula

CRUD com JSP 28

[Link]
drop database if exists aula;

create database aula;

use aula;

create table funcionario(

idFuncionario int primary key auto_increment,
nome varchar(35),
salario float
);

package entity;

public class Funcionario {

private Integer idFuncionario;
private String nome;
private Double salario;

public Funcionario() {
// TODO Auto-generated constructor stub
}

public Funcionario(Integer idFuncionario, String nome,

Double salario) {
super();
[Link] = idFuncionario;
[Link] = nome;
[Link] = salario;
}

@Override
public String toString() {
return "Funcionario [idFuncionario=" + idFuncionario
+ ", nome=" + nome + ", salario=" + salario + "]";
}

public Integer getIdFuncionario() {

return idFuncionario;

[Link] 2
 Apostila Java Básico Aula

CRUD com JSP 28

}
public void setIdFuncionario(Integer idFuncionario) {
[Link] = idFuncionario;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
public Double getSalario() {
return salario;
}
public void setSalario(Double salario) {
[Link] = salario;
}
}

package persistence;

import [Link];
import [Link];
import [Link];
import [Link];

public class Dao {

Connection con;
PreparedStatement stmt;
ResultSet rs;

public void open() throws Exception{

[Link]("[Link]");
con =
[Link]("jdbc:mysql://localhost:3306/aula",
"usuario","senha");
}

public void close() throws Exception{

[Link]();
}
}

[Link] 3
 Apostila Java Básico Aula

CRUD com JSP 28

package persistence;

import [Link];
import [Link];

import [Link];

public class FuncionarioDao extends

Dao{
public void create(Funcionario f) throws Exception{
open();
stmt = [Link]("insert into
funcionario values(null,?,?)");
[Link](1, [Link]());
[Link](2, [Link]());
[Link]();
[Link]();
close();
}

public void delete(int cod) throws Exception{

open();
stmt = [Link]("delete from
funcionario where idFuncionario = ?");
[Link](1, cod);
[Link]();
[Link]();
close();
}

public void update(Funcionario f) throws Exception{

open();
stmt = [Link]("update funcionario
set nome = ? , salario = ? where idFuncionario = ?");
[Link](1, [Link]());
[Link](2, [Link]());
[Link](3, [Link]());
[Link]();
[Link]();
close();
}

[Link] 4
 Apostila Java Básico Aula

CRUD com JSP 28

public List findAll() throws Exception{
open();
stmt = [Link]("select * from funcionario");
rs = [Link]();
List lista = new ArrayList();
while([Link]()){
Funcionario funcionario = new Funcionario();
[Link]([Link](1));
[Link]([Link](2));
[Link]([Link](3));
[Link](funcionario);
}
[Link]();
close();
return lista;
}

public Funcionario findByCode(int cod) throws Exception{

open();
stmt = [Link]("select * from
Funcionario where idFuncionario = ?");
[Link](1, cod);
rs = [Link]();
Funcionario funcionario = null;
if([Link]()){
funcionario = new Funcionario();
[Link]([Link](1));
[Link]([Link](2));
[Link]([Link](3));
}
[Link]();
close();
return funcionario;
}
}

package manager;

import [Link];
import [Link];

import [Link];

[Link] 5
 Apostila Java Básico Aula

CRUD com JSP 28

public class ManagerBean {
private List lista;

public List getLista() {

try {
lista = new ArrayList<>();
lista = new FuncionarioDao().findAll();
} catch (Exception e) {
[Link]([Link]());
}
return lista;
}

public void setLista(List lista) {

[Link] = lista;
}
}

package control;

import [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];

@WebServlet("/Controle")
public class Controle extends
HttpServlet {
private static final long serialVersionUID = 1L;

public Controle() {
super();
}

[Link] 6
 Apostila Java Básico Aula

CRUD com JSP 28

// doGet -> São requisições das paginas jsps enviadas por
link
protected void doGet(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException {

String cmd = [Link]("cmd");

if([Link]("buscar")){
buscar(request,response);
}
if([Link]("excluir")){
excluir(request,response);
}
}

// doPost -> São requisições das paginas jsps enviadas por

formulario
protected void doPost(HttpServletRequest request,
HttpServletResponse response) throws ServletException,
IOException {
// comando para resgatar um valor da pagina JSP
String cmd = [Link]("cmd");
if([Link]("gravar")){
gravar(request,response);
}
if([Link]("alterar")){
alterar(request,response);
}
}

protected void gravar(HttpServletRequest request,

HttpServletResponse response) throws ServletException,
IOException {

String nome = [Link]("nome");

Double salario = new
Double([Link]("salario"));
Funcionario f = new Funcionario();
[Link](nome);
[Link](salario);
try {
new FuncionarioDao().create(f);
// Comando para enviar uma msg para pagina jsp
[Link]("msg", "Dados Gravados");
} catch (Exception e) {

[Link] 7
 Apostila Java Básico Aula

CRUD com JSP 28

[Link]("msg", "Error" + [Link]());
}
finally{
//Comando para redirecionar para pagina jsp de resposta
[Link]("[Link]").forward(request
, response);
}
}

protected void buscar(HttpServletRequest request,

HttpServletResponse response) throws ServletException,
IOException {
Integer cod = new
Integer([Link]("cod"));
try {
Funcionario func = new FuncionarioDao().findByCode(cod);
[Link]("funcionario", func);
[Link]("[Link]").forward(request,
response);
} catch (Exception e) {
[Link]("msg", "Error " +
[Link]());
[Link]("[Link]").forward(request
, response);
}
}

protected void alterar(HttpServletRequest request,

HttpServletResponse response) throws ServletException,
IOException {
Integer cod = new
Integer([Link]("cod"));
String nome = [Link]("nome");
Double salario = new
Double([Link]("salario"));
Funcionario f = new Funcionario();
[Link](cod);
[Link](nome);
[Link](salario);
try {
new FuncionarioDao().update(f);
[Link]("msg", "Dados Alterados");
[Link]("[Link]").forward(request,
response);
} catch (Exception e) {

[Link] 8
 Apostila Java Básico Aula

CRUD com JSP 28

[Link]("msg", "Error" + [Link]());
[Link]("[Link]").forward(request
, response);
}
}

protected void excluir(HttpServletRequest request,

HttpServletResponse response) throws ServletException,
IOException {
Integer cod = new
Integer([Link]("cod"));
try {
new FuncionarioDao().delete(cod);
[Link]("msg", "Dados Excluídos");
[Link]("[Link]").forward(request,
response);
} catch (Exception e) {
[Link]("msg", "Error " +
[Link]());
[Link]("[Link]").forward(request
, response);
}
}
}

[Link]
<h2> Cadastro de Funcionario </h2>

<form method="post" action="Controle?cmd=gravar">

Nome <p/>
<input type="text" name="nome" size="35">
<br/>
Salario <p/>
<input type="text" name="salario" size="35">
<br/>
<input type="submit" value="Cadastrar"/>

</form>

${msg}
<br/>

[Link] 9
 Apostila Java Básico Aula

CRUD com JSP 28

<a href="[Link]">Listagem dos Funcionarios</a>

[Link]
<%@page import="entity.*, persistence.*"%>
<%@ taglib prefix="c" uri="[Link] %>
<jsp:useBean id="mb" class="[Link]"
scope="request"/>

<table border=1 >

<tr>
<th> Codigo </th>
<th> Funcionario </th>
<th> Salario </th>
<th> Alterar </th>
<th> Excluir </th>

</tr>

<c:forEach items="${[Link]}" var="linha">

[Link] 10
 Apostila Java Básico Aula

CRUD com JSP 28

<tr>
<td> ${[Link]}</td>
<td> ${[Link]}</td>
<td> ${[Link]}</td>
<td> <a
href="Controle?cmd=buscar&cod=${[Link]}"> Alterar
</a> </td>
<td> <a
href="Controle?cmd=excluir&cod=${[Link]}"> Excluir
</a> </td>
</tr>
</c:forEach>

</table>

${msg}
<br/>
<a href="[Link]">Voltar para Principal</a>

[Link]
<%@page import="entity.*, persistence.*"%>

<%
if([Link]("funcionario") != null){

Funcionario func = (Funcionario)

[Link]("funcionario");
%>

<form method="post" action="Controle?cmd=alterar">

Codigo <p/>
<input type="text" name="cod"
value="<%=[Link]() %>" readonly="readonly"
size="5">
<br/>
Nome <p/>
<input type="text" name="nome"
value="<%=[Link]() %>" size="35">
<br/>
Salario <p/>

[Link] 11
 Apostila Java Básico Aula

CRUD com JSP 28

<input type="text" name="salario"
value="<%=[Link]() %>" size="35">
<br/>
<input type="submit" value="Alterar"/>

</form>

<%
}
%>
${msg}
<a href="[Link]">Voltar</a>

[Link] 12
 Apostila Java Básico Aula

Modelagem 29
Modelagem de dados em Java com UML
O Objetivo deste artigo é fornecer uma introdução à modelagem de Classes
em Java utilizando diagramas UML. Neste exemplo iremos abordar o primeiro
tipo de relacionamento aprendido em Orientação a Objetos: SER (É-UM)
utilizado entre Classes e também entre Interfaces. Para tal iremos partir do
principio, ou seja, o tipo mais “puro” de objeto Java, denominado JavaBean

Classe JavaBean

Classe Java de Entidade (Modelagem)

Características:
 Atributos privados.
 Construtor default (vazio)
 Sobrecarga de Construtor (Entrada de dados)
 Encapsulamento
 Sobrescrita dos métodos de Object
 toString
 equals
 hashCode
 Serialização (Opcional)

package heranca;

public class Cliente {

private Integer idCliente;
private String nome;

public Cliente() {
}

public Cliente(Integer idCliente, String nome) {

super();
[Link] = idCliente;
[Link] = nome;
}

[Link] 1
 Apostila Java Básico Aula

Modelagem 29
@Override
public String toString() {
return idCliente + ", " + nome;
}

public Integer getIdCliente() {

return idCliente;
}
public void setIdCliente(Integer idCliente) {
[Link] = idCliente;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}
}

Visibilidades:
- private Acesso somente dentro da Classe.
~ default Acesso somente por classes do mesmo pacote.
# protected Acesso por pacote e por herança.
+ public Acesso total.
Herança (É-UM)

package heranca;

public class PessoaFisica extends

Cliente{
private String cpf;

public PessoaFisica() {
}

public PessoaFisica(Integer idCliente, String nome, String

cpf) {
super(idCliente, nome);
[Link] = cpf;

[Link] 2
 Apostila Java Básico Aula

Modelagem 29
}

@Override
public String toString() {
return [Link]() + ", " + cpf;
}

public String getCpf() {

return cpf;
}
public void setCpf(String cpf) {
[Link] = cpf;
}
}

Implementação (É-UM):
Componente de programação OO totalmente abstrato. Tem como
caracteristicas: Padronização.

 Interfaces Não possuem construtores.

 Seus atributos são final (constantes).

[Link] 3
 Apostila Java Básico Aula

Modelagem 29
 Métodos são publicos e abstratos (não tem corpo).
 Quando uma classe implementa uma interface, ela é obrigada a
fornecer corpo para os metodos da interface (desde que não seja uma
classe abstrata).

package relacionamento;

public interface IArquivo {

void abrirArquivo();
void gravarArquivo(String conteudo);
void fecharArquivo();

UML, qualquer nome em itálico, representa algo abstrato ou interface.

No próximo artigo iremos estudar o segundo tipo de relacionamento entre

Classes denominado TER (Todo/Parte) e suas variações como Agregação,
Composição, Dependência e suas Multiplicidades.

[Link] 4
 Apostila Java Básico Aula

Modelagem 29
package entity;

public abstract class Automovel {

private Integer idAutomovel;
private String nome;

public Automovel() {
}

public Automovel(Integer idAutomovel, String nome) {

[Link] = idAutomovel;
[Link] = nome;
}

@Override
public String toString() {
return idAutomovel + ", " + nome;
}

public Integer getIdAutomovel() {

return idAutomovel;
}
public void setIdAutomovel(Integer idAutomovel) {
[Link] = idAutomovel;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
[Link] = nome;
}

// Métodos abstratos
public abstract void setFabricante(String fabricante);
public abstract String getFabricante();
}

[Link] 5
 Apostila Java Básico Aula

Modelagem 29
No exemplo acima podemos dizer que CarroEsportivo É Automovel e
CarroExecutivo É Automovel, portanto, a herança da Classe abstrata configura
o uso de Polimorfismo. Note que Transformamos o objeto Automovel em
CarroEsportivo e CarroExecutivo

[Link] 6