# Apostila Java Webdeveloper Basico - Parte 1
## Criando um projeto local
Clicar no menu :arrow_right: File New :arrow_right: Java Project
Digitar o nome do projeto :arrow_right: next
Clicar em ==Finish==
Abrir a estrutura do projeto clicando na seta
### Para criar o pacote ou diretorio
Clicar em ==src== com o botão direito :arrow_right: new :arrow_right: package
Digitar o nome do pacote :arrow_right: finish
### Para criar a classe
Clicar no pacote com o botão direito :arrow_right: new :arrow_right: class
Digitar o nome da classe (sempre com a letra inicial maiuscula :arrow_right: finish
Classe criada
## Passo a passo para criar um projeto no STS
Abrir o STS -> Clicar no menu File -> Clicar em New -> Clicar em Java Project
Digitar o nome do projeto -> Clicar em Finish
*Aguardar o projeto ser criado*
Clicar no diretorio SRC com o botão direito -> Clicar em New -> Clicar em package
Digitar o nome do diretorio `br.com.arq` -> Clicar em Finish
Clicar no diretorio criado com o botão direito -> Clicar em New -> Clicar em Class
Digitar o nome da classe `main` -> Clicar em Finish
.
.
.
## Importando um Projeto Java Project
No menu do STS clicar em File -> Import
Selecionar Existing project into workspace -> Next
Clicar em Browse
Selecionar onde o projeto de exemplo está localizado -> Clicar em Selecionar Pasta
Clicar em Finish
*Aguardar baixar as dependências da internet ⏳*
## Atalhos do Eclipse
| TECLAS | O que faz |
| -------- | -------- |
| CTRL + S | Salvar a classe |
| CTRL + SHIFT + S | Salvar todas as classes |
| CTRL + ESPAÇO | Autocompleta os comandos |
| ALT + S | Atalho para getters and setters e construtores |
| CTRL + SHIFT + O | Faz algumas das importações |
| CTRL + W | Fecha a aba |
| CTRL + SHIFT + W | Fecha todas as abas |
| CTRL + D | Exclui a linha |
| F11 | Rodar o main |
| CTRL + PG UP | Pula as abas das classes para frente |
| CTRL + PG DOWN | Pula as abas das classes para trás |
| CTRL + SHIFT + F | Formata as o texto |
| CTRL + N | cria novo arquivo |
| CTRL + SHIFT + L | Listar todos os atalhos |
## Criando um Dynamic Web Project
Clicar no menu :arrow_right: file :arrow_right: new :arrow_right: dynamic web Project
Digitar o nome do projeto :arrow_right: Clicar em new runtime
### [Download do Apache TomCat](https://tomcat.apache.org/download-90.cgi "Clique para baixar")
Selecionar o [Apache TomCat](http://tomcat.apache.org/ "Ir no site") :cat: -> next
Clicar em browser para indicar onde está o Apache TomCat
Clicar em finish
Mudar a versão do dynamic web module para 3.1 -> next
Next
Clicar em generate web.xml :arrow_right: Finish
## Importando um Projeto Local
Abrir o Eclipse. Clicar em File :arrow_right: Import.
Clicar em general :arrow_right: Existing Projects into Workspace :arrow_right: Next.
Clicar em Browse e apontar onde está o diretório do projeto.
Clicar na pasta :arrow_right: OK.
Finish.
## Importando um Projeto Web
No menu do Eclipe clicar em File :arrow_right: Import.
Selecionar “war file” :arrow_right: next.
Clicar em browser para indicar onde se encontra o arquivo a ser importado.
Clicar no arquivo “war” :arrow_right: Abrir...
Clicar em Finish.
Projeto importado...
## Downloads de Programas
### [Eclipse Oxygen](https://www.eclipse.org/downloads/packages/release/oxygen/3a/eclipse-ide-java-ee-developers "Clique para baixar")
:point_right: https://www.eclipse.org/downloads/packages/release/oxygen/3a/eclipse-ide-java-ee-developers
Atualmente é a versão mais estável.
### [JDK 8](https://www.oracle.com/technetwork/pt/java/javase/downloads/jdk8-downloads-2133151.html "Clique para baixar")
:point_right: https://www.oracle.com/technetwork/pt/java/javase/downloads/jdk8-downloads-2133151.html
### MySql
:point_right: https://dev.mysql.com/downloads/mysql/
Baixar a versão: **5.7.29** que utilizamos nas aulas.
## :elephant: PostgreSQL
:link: **`https://www.postgresql.org/`**
**PostgreSQL** é um sistema de banco de dados relacional orientado a objetos poderoso e de código aberto, com mais de 30 anos de desenvolvimento ativo, que ganhou uma forte reputação de confiabilidade, robustez de recursos e desempenho.
## Orientação a objetos
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.
**Programação Orientada a Objetos** (também conhecida pela sua sigla POO) é um modelo de análise, projeto e programação de software baseado na composição e interação entre diversas unidades chamadas de 'objetos'. A POO é um dos 4 principais paradigmas de programação (as outras são programação imperativa, funcional e lógica). Os objetos são operados com o conceito de 'this' (isso) ou 'self' (si), de forma que seus métodos (muitas vezes) modifiquem os dados da própria instância. Os programas são arquitetados através de objetos que interagem entre si. Dentre as várias abordagens da POO, as baseadas em classes são as mais comuns: objetos são instâncias de classes, o que em geral também define o tipo do objeto. Cada classe determina o comportamento (definido nos métodos) e estados possíveis (atributos) de seus objetos, assim como o relacionamento com outros objetos. A alternativa mais usual ao uso de classes é o uso de protótipos. Neste caso, objetos são cópias de outros objetos, não instâncias de classes. Javascript e Lua são exemplos de linguagens cuja POO é realizada por protótipos. A diferença prática mais evidente é que na POO baseada em protótipos apenas a herança simples é implementada pela cópia do objeto. Assim, na POO, implementa-se um conjunto de classes passíveis de serem instanciadas como objetos, e.g. Python e C++ (ou objetos protótipos que são copiados e alterados, e.g. JavaScript e VimL).
Em alguns contextos, o termo modelagem orientada ao objeto (MOO) é preferível ao termo POO. De fato, o paradigma "orientado ao objeto" tem origem nos estudos da cognição e influenciou a inteligência artificial e a linguística, dada a relevância para a abstração de conceitos do mundo real. A MOO é considerada a melhor estratégia para diminuir o "gap semântico" (o hiato entre o mundo real e a representação dele), e facilita a comunicação das partes interessadas no modelo ou software (e.g. o modelador e o usuário final) na medida em que conceitos, terminologia, símbolos, grafismo e estratégias, são, potencialmente, mais óbvios, intuitivos, naturais e exatos.
Muitas das linguagens de programação mais utilizadas atualmente (talvez a maioria) são multi-paradigma com suporte à POO. C++, C#, VB.NET, Java, Object Pascal, Objective-C, Python, SuperCollider, Ruby e Smalltalk são exemplos de linguagens de programação orientadas a objetos. ActionScript, ColdFusion, Javascript, PHP (a partir da versão 4.0), Perl (a partir da versão 5), Visual Basic (a partir da versão 4), VimL (ou Vim script) são exemplos de linguagens de programação com suporte a orientação a objetos. Vivace é um exemplo de linguagem sem suporte à POO.
Os **atributos e métodos** podem ser referentes a uma classe (e todas as suas instâncias) ou a uma única instância. O vínculo dos atributos aos métodos, de forma a manter uma interface bem definida para operação sobre os dados, e a evitar corrupção dos dados, é chamado de encapsulamento. O encapsulamento foi responsável pelo conceito de 'ocultamento de dados', central para a POO. O encapsulamento pode ser realizado através de convenções (em Python, underscores demarcam métodos e atributos protegidos e privados), ou via recursos da linguagem (em Java ou C++, um método privado só é acessado pela própria classe). Encapsulamento incentiva o desacoplamento.
Quando um objeto contém outros objetos, diz-se que há composição de objetos. A composição de objetos é usada para representar uma relação 'tem um', usualmente uma meronímia. Já a herança (quase sempre suportada pelas linguagens que utilizam classes) apresenta relações 'é um' (i.e. 'é um tipo de'), ou seja, relações de hiperonímia cujo resultado final é a árvore taxonômica. Na herança, tipicamente todos os atributos e métodos da classe pai/mãe estão também disponíveis na classe filha, embora seja comum que algumas características sejam substituídas. Assim, a herança permite reúso facilitado de características e muitas vezes reflete relações do mundo real de forma intuitiva. Ambas a 'composição de objetos' e a 'herança' constituem hierarquias entre as classes e objetos na POO.
### 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.
### Modificadores de acesso do Java
Em Java, podemos criar atributos ou métodos com os seguintes modificadores de acesso:
- **public** - Acesso total, qualquer classe tem acesso ao método (não indicado para usar em atributos de entidade).
- **protected** - Acesso permitido por herança e por classes do mesmo pacote.
- **default / friendly** - Acesso permitido somente a classes do mesmo pacote, este acesso é definido quando não declaramos nenhum modificador.
- **private** - Acesso permitido somente dentro da própria classe. (indicado para atributos de classes de entidade).
## 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)
```java=
package heranca;
public class Cliente {
private Integer idCliente;
private String nome;
public Cliente() {
}
public Cliente(Integer idCliente, String nome) {
super();
this.idCliente = idCliente;
this.nome = nome;
}
@Override
public String toString() {
return idCliente + ", " + nome;
}
public Integer getIdCliente() {
return idCliente;
}
public void setIdCliente(Integer idCliente) {
this.idCliente = idCliente;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = 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.
```java=
package heranca;
public class PessoaFisica extends Cliente {
private String cpf;
public PessoaFisica() {
}
public PessoaFisica(Integer idCliente, String nome, String cpf) {
super(idCliente, nome);
this.cpf = cpf;
}
@Override
public String toString() {
return super.toString() + ", " + cpf;
}
public String getCpf() {
return cpf;
}
public void setCpf(String cpf) {
this.cpf = 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).
- 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).
```java=
package relacionamento;
public interface IArquivo {
void abrirArquivo();
void gravarArquivo(String conteudo);
void fecharArquivo();
}
```
Quando uma Classe não abstrata (comum) herda (implementa) uma interface, esta é obrigada a fornecer corpo para os metodos da interface. Por exemplo:
```java=
package relacionamento;
public class Documento implements IArquivo {
@Override
public void abrirArquivo() {
// TODO Auto-generated method stub
}
@Override
public void gravarArquivo(String conteudo) {
// TODO Auto-generated method stub
}
@Override
public void fecharArquivo() {
// TODO Auto-generated method stub
}
}
```
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.
```java=
package entity2;
public abstract class Automovel {
private Integer idAutomovel;
private String nome;
public Automovel() {
}
public Automovel(Integer idAutomovel, String nome) {
this.idAutomovel = idAutomovel;
this.nome = nome;
}
@Override
public String toString() {
return idAutomovel + ", " + nome;
}
public Integer getIdAutomovel() {
return idAutomovel;
}
public void setIdAutomovel(Integer idAutomovel) {
this.idAutomovel = idAutomovel;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
// Métodos abstratos
public abstract void setFabricante(String fabricante);
public abstract String getFabricante();
}
```
### Classes comuns herdando da Classe Abstrata
```java=
package entity2;
public class CarroEsportivo extends Automovel {
private Integer ano;
private String fabricante;
public CarroEsportivo() {
}
public CarroEsportivo(Integer idAutomovel, String nome,
Integer ano, String fabricante) {
super(idAutomovel, nome);
this.ano = ano;
this.fabricante = fabricante;
}
@Override
public String toString() {
return super.toString() + ", " + ano + ", " + fabricante;
}
public Integer getAno() {
return ano;
}
public void setAno(Integer ano) {
this.ano = ano;
}
@Override
public String getFabricante() {
return fabricante;
}
@Override
public void setFabricante(String fabricante) {
this.fabricante = fabricante;
}
}
```
.
```java=
package entity2;
public class CarroExecutivo extends Automovel {
private String modelo;
private String fabricante;
public CarroExecutivo() {
}
public CarroExecutivo(Integer idAutomovel, String nome,
String modelo,
String fabricante) {
super(idAutomovel, nome);
this.modelo = modelo;
this.fabricante = fabricante;
}
@Override
public String toString() {
return super.toString() + ", " + modelo + ", "
+ fabricante;
}
public String getModelo() {
return modelo;
}
public void setModelo(String modelo) {
this.modelo = modelo;
}
@Override
public String getFabricante() {
return fabricante;
}
@Override
public void setFabricante(String fabricante) {
this.fabricante = fabricante;
}
}
```
```java=
package main;
import entity2.Automovel;
import entity2.CarroEsportivo;
import entity2.CarroExecutivo;
public class Main {
public static void main(String[] args) {
Automovel a1 = new CarroEsportivo(1, "Ferrari", 2012,
"Ferrari Italia");
Automovel a2 = new CarroExecutivo(2, "C4", "Sedan",
"Citroen");
System.out.println(a1);
System.out.println(a2);
}
}
```
>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 [color=#907bf7]
## O que é uma classe
Uma classe define estado e comportamento de um Objeto geralmente implementando métodos e atributos (nomes utilizados na maioria das linguagens modernas). Os atributos, também chamados de campos (do inglês fields), indicam as possíveis informações armazenadas por um objeto de uma classe, representando o estado de cada objeto. Os métodos são procedimentos que formam os comportamentos e serviços oferecidos por objetos de uma classe.
Uma classe é uma estrutura que abstrai um conjunto de objetos com características similares. Uma classe define o comportamento de seus objetos - através de métodos - e os estados possíveis destes objetos - através de atributos. Em outras palavras, uma classe descreve os serviços oferecidos por seus objetos e quais informações eles podem armazenar. Classes não são diretamente suportadas em todas as linguagens, e são necessárias para que uma linguagem seja orientada a objetos. Uma classe representa um conjunto de objetos com características afins. Uma classe define o comportamento dos objetos através de seus métodos, e quais estados ele é capaz de manter através de seus atributos.
## Classe Java Beans
JavaBeans são componentes de software escritos na linguagem de programação Java. Segundo a especificação da Sun Microsystems os JavaBeans são "componentes reutilizáveis de software que podem ser manipulados visualmente com a ajuda de uma ferramenta de desenvolvimento".
Um bean também pode ser definido como uma classe Java que expõe propriedades, seguindo uma convenção de nomeclatura simples para os métodos getter e setter.
Praticamente são classes escritas de acordo com uma convenção em particular. São usados para encapsular muitos objetos em um único objeto (o bean), assim eles podem ser transmitidos como um único objeto em vez de vários objetos individuais.
São características de uma Classe JavaBean:
* Atributos privados
* Construtores
* Vazio (sem argumentos)
* Com entrada de argumetos (Sobrecarga)
* Métodos set e get (encapsulamento)
* Sobrescrita dos métodos da Classe Object
* toString
* equals
* hashCode
## Objeto
É uma instância de uma Classe. Armazenamento de estados através de seus atributos e reação a mensagens enviadas por outros objetos.
Cliente c1 = new Cliente();
[Classe] [Objeto] [Construtor :arrow_right: Instância]
Um objeto, na vida real, é qualquer coisa a qual pudermos dar um nome. Um objeto, em programação orientada a objetos, é uma instância (ou seja, um exemplar) de uma classe. A Wikilivros é um exemplo de Wiki, ou, a Wikilivros é uma instância de Wiki. Isto poderia ser representado em um programa orientado a objetos com uma classe chamada Wiki e um objeto do tipo Wiki chamado Wikilivros. Um objeto é capaz de armazenar estados através de seus atributos e reagir a mensagens enviadas a ele, assim como se relacionar e enviar mensagens a outros objetos. **Atributos** são características de um objeto. Basicamente a estrutura de dados que vai representar a classe. Exemplos: um objeto da classe "Funcionário" teria como atributos "nome", "endereço", "telefone", "CPF", etc. O conjunto de valores dos atributos de um determinado objeto é chamado de estado.
## Padrão MVC - Model, View e Controller
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.
**Camada Model**
```java=
package modelo;
public class Pessoa {
private Integer idPessoa;
private String nome;
private Integer idade;
public Pessoa() {
}
public Pessoa(Integer idPessoa, String nome, Integer idade) {
super();
this.idPessoa = idPessoa;
this.nome = nome;
this.idade = idade;
}
@Override
public String toString() {
return "Pessoa [idPessoa=" + idPessoa + ", nome=" + nome
+ ", idade=" + idade + "]";
}
public Integer getIdPessoa() {
return idPessoa;
}
public void setIdPessoa(Integer idPessoa) {
this.idPessoa = idPessoa;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public Integer getIdade() {
return idade;
}
public void setIdade(Integer idade) {
this.idade = idade;
}
}
```
**Camada Controle**
```java=
package controle;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import modelo.Pessoa;
public class ValidaPessoa {
public void validaCodigo(Pessoa p)throws Exception{
if (p.getIdPessoa()<=0){
throw new Exception("Codigo Menor ou igual a zero
invalido ...");
}
}
public void validaIdade(Pessoa p)throws Exception{
if (p.getIdade()<18){
throw new Exception("So pode ser cadastrado
maior de idade");
}
}
public void validaNome(Pessoa p)throws Exception{
Pattern pa = Pattern.compile("[A-Z a-z]{3,35}");
Matcher ma = pa.matcher(p.getNome());
if (! ma.matches()){
throw new Exception("Nome somente com
Letras faixa (3,35)");
}//se for falso lança o erro
}
}
```
**Camada View**
```java=
package view;
import java.util.Scanner;
public class InputPessoa {
public Integer lerCodigo() {
try {
System.out.println("Digite o Codigo :");
Scanner in = new Scanner(System.in);
return in.nextInt();
} catch (Exception ex) {
System.out.println("Digite numero inteiro ...");
return lerCodigo();
}
}
public Integer lerIdade() {
try {
System.out.println("Digite a Idade :");
Scanner in = new Scanner(System.in);
return in.nextInt();
} catch (Exception ex) {
System.out.println("Digite idade inteira ...");
return lerIdade();
}
}
public String lerNome() {
System.out.println("Digite o Nome :");
Scanner in = new Scanner(System.in);
return in.nextLine();
}
}
```
Execução do Programa no Main
```java=
package main;
import modelo.Pessoa;
import view.InputPessoa;
import controle.ValidaPessoa;
public class Main {
public static void main(String[] args) {
Pessoa p = new Pessoa();
InputPessoa ip = new InputPessoa();
ValidaPessoa vp = new ValidaPessoa();
try{
p.setIdPessoa(ip.lerCodigo());
p.setNome(ip.lerNome());
p.setIdade(ip.lerIdade());
vp.validaCodigo(p);
vp.validaNome(p);
vp.validaIdade(p);
System.out.println("Dados" + p);
}catch(Exception ex){
System.out.println("Error" + ex.getMessage());
}
}
}
```
## Encapsulamento
Em linguagens orientadas a objetos, é possível encapsular o estado de um objeto. Em termos práticos, isso se realiza limitando o acesso a atributos de uma classe exclusivamente através de seus métodos. Para isso, as linguagens orientadas a objeto oferecem limitadores de acesso para cada membro de uma classe.
Tipicamente os limitadores de acesso são:
* **público (public)** - o membro pode ser acessado por qualquer classe. Os membros públicos de uma classe definem sua interface
* **protegido (protected)** - o membro pode ser acessado apenas pela própria classe e suas sub-classes
* **privado (private)** - o membro pode ser acessado apenas pela própria classe
Cada linguagem de programação pode possuir limitadores de acesso próprios. Por exemplo, em Java, o nível de acesso padrão de um membro permite que qualquer classe de seu pacote (package) possa ser acessado. Em C♯, o limitador de acesso interno (internal) permite que o membro seja acessado por qualquer classe do Assembly (isto é, da biblioteca ou executável).
É um conceito da orientação a objetos 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.
```java=
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();
this.idAluno = idAluno;
this.nomeAluno = nomeAluno;
this.nota1 = nota1;
this.nota2 = nota2;
}
@Override
public String toString() {
return "Aluno [idAluno=" + idAluno + ", nomeAluno="
+ nomeAluno + ", nota1=" + nota1 + ", nota2=" + nota2 + "]";
}
public Integer getIdAluno() {
return idAluno;
}
public void setIdAluno(Integer idAluno) {
this.idAluno = idAluno;
}
public String getNomeAluno() {
return nomeAluno;
}
public void setNomeAluno(String nomeAluno) {
this.nomeAluno = 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;
}
}
```
.
```java=
package main;
import entity.Aluno;
public class Main {
public static void main(String[] args) {
//O encapsulamento utilizando set e get
Aluno a1 = new Aluno();
a1.setIdAluno(1);
a1.setNomeAluno("luiz");
a1.setNota1(7.);
a1.setNota2(8.);
System.out.println("Nome: " + a1.getNomeAluno() +
"Nota1: " + a1.getNota1() +
"Nota2: " + a1.getNota2()
);
//------------------------------------------------
// O encapsulamento utilizando Construtor cheio e
// toString ( representado pelo objeto )
Aluno a2 = new Aluno(2,"Joao",8.,6.);
System.out.println("Dados: " + a2);
}
}
```
## Herança
A herança é um relacionamento pelo qual uma classe, chamada de sub-classe, herda todos comportamentos e estados possíveis de outra classe, chamada de super-classe ou classe base. É permitido que a sub-classe estenda os comportamentos e estados possíveis da super-classe (por isso este relacionamento também é chamado de extensão). Essa extensão ocorre adicionando novos membros a sub-classe, como novos métodos e atributos.
É também possível que a sub-classe altere os comportamentos e estados possíveis da super-classe. Neste caso, a sub-classe sobrescreve membros da super-classe, tipicamente métodos.
Quando uma classe herda de mais de uma super-classe, ocorre uma herança múltipla. Esta técnica é possível em C++ e em Python, mas não é possível em Java e C♯, no entanto estas linguagens permitem múltipla tipagem através do uso de interfaces.
O objetivo da herança no Java é agrupar atributos comuns de varias classes em uma única classe denominada Super-Classe, e as características especificas ficam na Sub-Classe. No Java o comando que representa a herança é chamado extends. E uma Sub-Classe não pode ter mais de uma Super-Classe.
**super() x super**
O comando Java super() , “super com parêntese” , no construtor da sub-Classe tem a finalidade de chamar os atributos da Super-Classe. O comando obrigatoriamente fica localizado na primeira linha do construtor cheio.
```java=
public Aluno(String nome, String email, Double nota1, Double nota2) {
super(nome, email);
this.nota1 = nota1;
this.nota2 = nota2;
}
```
O comando Java super, “super sem parêntese” , no método da sub-classe tem a finalidade de chamar o método com o mesmo nome da Super-Classe.
```java=
@Override
public String toString() {
return super.toString() + "Aluno [nota1=" + nota1 +
", nota2=" + nota2 + "]";
}
```
Apresentação das Classes no Java.
Super-Classe Pessoa possui os atributos comuns as Sub-Classes Aluno e Professor.
```java=
package entity;
public class Pessoa {
private String nome;
private String email;
public Pessoa() {
}
public Pessoa(String nome, String email) {
super();
this.nome = nome;
this.email = email;
}
@Override
public String toString() {
return "Pessoa [nome=" + nome + ", email=" + email + "]";
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
```
Sub-Classes Aluno e Professor com esses atributos específicos.
```java=
package entity;
public class Aluno extends Pessoa {
public Double nota1;
public Double nota2;
public transient Double media;
public Aluno() {
}
public Aluno(String nome, String email, Double nota1, Double nota2) {
super(nome, email);
this.nota1 = nota1;
this.nota2 = nota2;
}
@Override
public String toString() {
return super.toString() + "Aluno [nota1=" + nota1
+ ", nota2=" + nota2 + "]";
}
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) {
this.media = media;
}
}
```
.
```java=
package entity;
public class Professor extends Pessoa {
private Integer matricula;
private Double salario;
public Professor() {
}
public Professor(String nome, String email, Integer matricula,
Double salario) {
super(nome, email);
this.matricula = matricula;
this.salario = salario;
}
@Override
public String toString() {
return super.toString() + "Professor [matricula="
+ matricula + ", salario=" + salario + "]";
}
public Integer getMatricula() {
return matricula;
}
public void setMatricula(Integer matricula) {
this.matricula = matricula;
}
public Double getSalario() {
return salario;
}
public void setSalario(Double salario) {
this.salario = salario;
}
}
```
.
```java=
package main;
import entity.Aluno;
import entity.Professor;
public class Main {
public static void main(String[] args) {
// Herança
// Instanciando os objetos pelas Sub-Classes
Aluno a = new Aluno("Jose","jose@gmail.com",10.,8.);
System.out.println(a);
//----------------------
Professor p = new Professor("Luiz","luiz@gmail.com",123,3000.);
System.out.println(p);
}
}
```
## NumberFormat
**NumberFormat** é uma classe base abstrata para todos os formatos numéricos. Esta classe fornece a interface para formatar e analisar números. NumberFormat também fornece métodos para determinar quais localidades (EUA, Índia, Itália etc.) têm formatos numéricos e quais são seus nomes. NumberFormat ajuda a formatar e analisar números para qualquer localidade.
**Exemplo**: suponha que tenhamos um número de tipo duplo. Mas esse número de tipo duplo é representado de maneiras diferentes em diferentes países. Para representar um número de acordo com vários países, precisamos da ajuda da classe NumberFormat, como:
> d duplo = 123456.789;
> Para a Índia, é representado como 1.233.456.789
> Para os EUA, é representado como 123.456.789
> Para a ITÁLIA, é representado como 123.456.789
### Alguns pontos importantes sobre a classe NumberFormat:
* A classe **NumberFormat** está presente no pacote java.text e é uma classe abstrata.
* A classe **NumberFormat** implementa Serializable, Cloneable.
* **NumberFormat** é a classe filho direta da classe Format.
* Os formatos numéricos geralmente não são sincronizados. É recomendável criar instâncias de formato separadas para cada thread. Se vários threads acessarem um formato simultaneamente, ele deverá ser sincronizado externamente.
### Os principais métodos do **NumberFormat** são:
* **getNumberInstance()** - Retorna a instância de um objeto com base no formato da localidade padrão. É utilizado para numeros
* **getCurrencyInstance()** - Usado para formatar moedas
* **getIntegerInstance()** - Usado para formatar números ignorando casas decimais
* **getPercentInstance()** - Usado para formatar frações pro exemplo 0,15 é formatado e mostrado como 15%
### Métodos presentes na classe **NumberFormat**:
* **NumberFormat público estático getInstance (); :** Para obter o objeto NumberFormat como localidade padrão.
* **NumberFormat público estático getCurrencyInstance (); :** Para obter o objeto NumberFormat do código de idioma padrão para representar em uma moeda específica.
* **public static NumberFormat getPercentInstance (); :**
* **NumberFormat público estático getInstance (Locale l); :** Para obter o objeto NumberFormat para o objeto Locale especificado.
* **formato estático público (long l); :** Para converter o número java em um objeto de localidade.
:point_right: Site: https://docs.oracle.com/javase/7/docs/api/java/text/NumberFormat.html
**NumberFormat** é a classe base abstrata para todos os formatos numéricos. Esta classe fornece a interface para formatar e analisar números. NumberFormattambém fornece métodos para determinar quais localidades possuem formatos numéricos e quais são seus nomes.
**NumberFormat** ajuda a formatar e analisar números para qualquer localidade. Seu código pode ser completamente independente das convenções de localidade para pontos decimais, separadores de milhares ou mesmo os dígitos decimais usados, ou se o formato do número é decimal.
Para formatar um número para a localidade atual, use um dos métodos de classe de fábrica:
```java=
myString = NumberFormat.getInstance (). format (myNumber);
```
Se você estiver formatando vários números, é mais eficiente obter o formato e usá-lo várias vezes, para que o sistema não precise buscar as informações sobre o idioma local e as convenções do país várias vezes.
```java=
NumberFormat nf = NumberFormat.getInstance ();
for (int i = 0; i <myNumber.length; ++ i) {
output.println (nf.format (meuNúmero [i]) + ";");
}
```
Para formatar um número para uma localidade diferente, especifique-o na chamada para getInstance.
```java=
NumberFormat nf = NumberFormat.getInstance (Locale.FRENCH);
```
Use **getInstance** ou **getNumberInstance** para obter o formato numérico normal. Use **getIntegerInstance** para obter um formato de número inteiro.
Use **getCurrencyInstance** para obter o formato do número da moeda. E use **getPercentInstance** para obter um formato para exibir porcentagens. Com esse formato, uma fração como 0,53 é exibida como 53%.
Você também pode controlar a exibição de números com métodos como **setMinimumFractionDigits**. Se você deseja ter ainda mais controle sobre o formato ou a análise, ou deseja dar a seus usuários mais controle, tente converter o **NumberFormat** que obtém dos métodos de fábrica para a **DecimalFormat**. Isso funcionará para a grande maioria dos locais; lembre-se de colocá-lo em um try bloco, caso você encontre um incomum.
**NumberFormat** e **DecimalFormat** são projetados para que alguns controles funcionem para formatação e outros funcionem para análise. A seguir, é apresentada a descrição detalhada de cada um desses métodos de controle.
## Sobrescrita de Métodos(Override)
A sobrescrita (ou override) está diretamente relacionada à orientação a objetos, mais especificamente com a herança. Com a sobrescrita, conseguimos especializar os métodos herdados das superclasses, alterando o seu comportamento nas subclasses por um mais específico. A sobrescrita de métodos consiste basicamente em criar um novo método na classe filha contendo a mesma assinatura e mesmo tipo de retorno do método sobrescrito.
Quando mencionado anteriormente que o método deve possuir a mesma assinatura, significa dizer que o método deve possuir o mesmo nome, a mesma quantidade e o mesmo tipo de parâmetros utilizado no método sobrescrito. Com relação ao tipo de retorno, este pode ser um subtipo do tipo de retorno do método sobrescrito, por exemplo: se o método da superclasse retornar um List, é permitido que o novo método retorne um ArrayList ou qualquer outro List. No entanto o oposto não é permitido, gerando um erro de compilação.
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.
```java=
package entity;
// A classe Object está implicita na classe Cliente
//public class Cliente extends Object
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) {
this.idCliente = idCliente;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
}
```
Quando uma Subclasse herda uma Superclasse. Nesse caso está sendo sobrescrito o método imprimirDescricao do Funcionario e reescrito no FuncionarioCLT.
```java=
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();
this.idFuncionario = idFuncionario;
this.nome = nome;
this.descricao = descricao;
}
@Override
public String toString() {
return "Funcionario [idFuncionario=" + idFuncionario +
", nome=" + nome + ", descricao=" + descricao + "]";
}
public Integer getIdFuncionario() {
return idFuncionario;
}
public void setIdFuncionario(Integer idFuncionario) {
this.idFuncionario = idFuncionario;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getDescricao() {
return descricao;
}
public void setDescricao(String descricao) {
this.descricao = descricao;
}
public String imprimirDescricao(){
return "Funcionario Padrao";
}
}
```
.
```java=
package entity;
public class FuncionarioCLT extends Funcionario {
public FuncionarioCLT() {
}
public FuncionarioCLT(Integer idFuncionario, String nome) {
super(idFuncionario, nome);
}
@Override
public String imprimirDescricao() {
return "Funcionario CLT";
}
}
```
.
```java=
package main;
import entity.Funcionario;
import entity.FuncionarioCLT;
public class Main {
public static void main(String[] args) {
Funcionario f = new Funcionario(1, "Joao");
System.out.println("Funcionario: " +
f + "\n Descricao: " + f.imprimirDescricao());
FuncionarioCLT f1 = new FuncionarioCLT(2, "Luiz");
System.out.println("\nFuncionario: " + f1 +
"\n Descricao: " + f1.imprimirDescricao());
}
}
```
Quando uma classe implementa uma Interface.
```java=
package entity;
public interface IArquivo {
public void open() throws Exception;
public void close() throws Exception;
}
```
.
```java=
package entity;
public class Arquivo implements IArquivo {
@Override
public void open() throws Exception {
System.out.println("Abrir o Arquivo");
}
@Override
public void close() throws Exception {
System.out.println("Fechar o Arquivo");
}
}
```
.
```java=
package main;
import entity.Arquivo;
public class Main {
public static void main(String[] args) {
Arquivo a = new Arquivo();
try {
a.open();
a.close();
} catch (Exception e) {
System.out.println("Error" + e.getMessage());
}
}
}
```
## Sobrecarga de Métodos(Overloading)
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.
```java=
package entity;
public class Cliente {
private Integer idCliente;
private String nome;
public Cliente() {
}
public Cliente(Integer idCliente, String nome) {
super();
this.idCliente = idCliente;
this.nome = nome;
}
}
```
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
```java=
package entity;
public class Numero {
public void print(int a){
System.out.println("Numero" + a);
}
public void print(int a, int b){
System.out.println("Numero" + a);
}
public void print(double a){
System.out.println("Numero" + a);
}
}
```
Nesse caso ocorre quando herda uma Superclasse
```java=
package entity;
public class Numero {
public void print(int a){
System.out.println("Numero" + a);
}
public void print(int a, int b){
System.out.println("Numero" + a);
}
public void print(double a){
System.out.println("Numero" + a);
}
}
```
```java=
package entity;
public class NumeroNatural extends Numero {
public void print(int a, int b, int c ){
System.out.println("Numeros" + a + b + c);
}
}
```
```java=
package main;
import entity.NumeroNatural;
public class Main {
public static void main(String[] args) {
NumeroNatural nn = new NumeroNatural();
//Metodos da SuperClasse Numero
nn.print(1);
nn.print(2.);
nn.print(3, 4);
//Metodo da SubClasse NumeroNatural
nn.print(3, 5, 4);
}
}
```
## Polimorfismo
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, um mesmo método pode apresentar várias formas, de acordo com seu contexto. O polimorfismo é importante pois permite que a semântica de uma interface seja efetivamente separada da implementação que a representa. O termo polimorfismo é originário do grego e significa 'muitas formas' (poli = muitas, morphos = formas).
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.
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.
### 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:
:arrow_right: Todos os métodos de uma interface são implicitamente públicos e abstratos.
:arrow_right: Todos os métodos de uma interface não possuem corpo, apenas assinatura.
:arrow_right: Os Atributos de uma interface são, por definição, constantes, ou seja, possuem valor final.
:arrow_right: Quando uma Classe implementa uma interface, a Classe deverá forecer corpo para todos os métodos da interface, exceto se a Classe for abstrata.
:arrow_right: Uma interface pode herdar de outras interfaces.
:arrow_right: 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):
* **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
## JOptionpane
.
JOptionPane é uma classe que possibilita a criação de uma caixa de dialogo padrão que ou solicita um valor para o usuário ou retorna uma informação. Abaixo encontra-se alguns metodos e parametros mais utilizados quando se opta pelo JOptionPane.
**Métodos**
|Método | Descrição|
|---|---|
|showConfirmDialog |Solicita uma confirmação como(YES, NO, CANCEL) |
|showInputDialog |Solicita algum valor |
|showMessageDialog |Informa ao usuário sobre algo |
|showOptionDialog |Unificação dos tres acima|
**Parametros**
|Parametro | Descrição|
|---|---|
|parentComponent |Define a caixa de diálogo onde irá aparece todo o conteúdo. Há duas maneiras de definir a caixa de diálogo a primeira você mesmo cria utilizando os conceitos da classe JFrame. A segunda, você define esse parametro como null e o java irá gerar uma caixa de diálogo padrão. |
|message |É a messagem que o usuário deve ler. Esta mensagem pode ser uma simples String ou um conjunto de objetos. |
|messageType| Define o estilo da mensagem. O gerente de aparencia pode expor a caixa de dialogo de formas diferentes,dependendo deste valor, pode fornecer um icone padrão. Exemplos: ERROR_MESSAGE - INFORMATION_MESSAGE - WARNING_MESSAGE - QUESTION_MESSAGE - PLAIN_MESSAGE|
| optionType |Define o conjunto de botões que irá aparecer na parte inferior da caixa de diálogo. Exemplos: DEFAULT_OPTION - YES_NO_OPTION - YES_NO_CANCEL_OPTION-OK_CANCEL_OPTION |
**Exemplo**
1. Mostra um diálogo de erro que exibe a mensagem “alerta”:
```java=
JOptionPane.showMessageDialog(null, “alerta”,
“alerta”, JOptionPane.ERROR_MESSAGE);
```
2. Mosta um painel de informação com as opções Sim/Não e exibe a mensagem: ‘Escolha um:’
```java=
JOptionPane.showConfirmDialog(null,”Escolha um:”,
“Escolha um”,JOptionPane.YES_NO_OPTION);
```
3. Mostrar uma janela de aviso com as opções OK, CANCELAR, o texto ‘Aviso’ no título e a mensagem ‘Clique em OK para continuar:
```java=
Object[] options = { “OK”, “CANCELAR” };
JOptionPane.showOptionDialog(null, “Clique OK para continuar”,
“Aviso”, JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE,
null, options, options[0]);
```
Note que se eu adicionar mais um item no vetor options, automaticamente adicionar mais um botão de opção com o nome que eu colocar.
```java=
Object[] options = { “OK”, “CANCELAR”,”VOLTAR” };
JOptionPane.showOptionDialog(null, “Clique OK para continuar”,
“Aviso”,
JOptionPane.DEFAULT_OPTION, JOptionPane.WARNING_MESSAGE,
null, options, options[0]);
```
4. Mostra uma caixa de diálogo solicitando que o usuário digite uma string:
```java=
String inputValue = JOptionPane.showInputDialog (“Please input a value”);
```
5. Mostra uma caixa de diálogo solicitando que o usuário selecione uma item:
```java=
Object[] itens = { “MAÇA”, “PERA”, “BANANA” };
Object selectedValue = JOptionPane.showInputDialog(null,
“Escolha um item”, “Opçao”,
JOptionPane.INFORMATION_MESSAGE, null,
itens, itens [0]); //
```
.
## Classe Enum
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.
```java=
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 super.toString();
}
private Bimestre(Integer pos) {
this.pos = pos;
}
public Integer getPos() {
return pos;
}
public void setPos(Integer pos) {
this.pos = pos;
}
public static void main(String[] args) {
for(Bimestre x : Bimestre.values() ){
System.out.println("Nome : " + x.name());
//PRIMEIRO, SEGUNDO, TERCEIRO, QUARTO
System.out.println("Posicao :" + x.ordinal());
// 0 , 1 , 2 , 3
System.out.println("Valor : " + x.getPos());
// 1 , 2 , 3 , 4
}
}
}
```
### 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.
.
## Criptografia MD5
O MD5 (Message-Digest algorithm 5) é uma função de dispersão criptográfica (ou função hash criptográfica) de 128 bits unidirecional desenvolvido pela RSA Data Security, Inc., descrito na RFC 1321, e muito utilizado por softwares com protocolo ponto-a-ponto (P2P, ou Peer-to-Peer, em inglês) na verificação de integridade de arquivos e logins.
Foi desenvolvido em 1991 por Ronald Rivest para suceder ao MD4 que tinha alguns problemas de segurança. Por ser um algoritmo unidirecional, uma hash md5 não pode ser transformada novamente no texto que lhe deu origem. O método de verificação é, então, feito pela comparação das duas hash (uma da mensagem original confiável e outra da mensagem recebida). O MD5 também é usado para verificar a integridade de um arquivo através, por exemplo, do programa md5sum, que cria a hash de um arquivo. Isto pode-se tornar muito útil para downloads de arquivos grandes, para programas P2P que constroem o arquivo através de pedaços e estão sujeitos a corrupção dos mesmos. Como autenticação de login é utilizada em vários sistemas operacionais unix e em muitos sites com autenticação.
Em 2008, Ronald Rivest e outros, publicaram uma nova versão do algoritmo o MD6 com hash de tamanhos 224, 256, 384 ou 512 bits. O algoritmo MD6 iria participar do concurso para ser o novo algoritmo SHA-3, porém logo depois removeu-o do concurso por considerá-lo muito lento, anunciando que os computadores de hoje são muito lentos para usar o MD6.
O md5 é uma função criptográfica, mas não deve ser confundido com criptografia. A encriptação é uma tarefa de mão dupla que você usa sempre que precisa armazenar com segurança uma informação, mas precisa recuperá-la mais tarde através de uma chave simétrica ou privada. Já o hash, é comumente utilizado quando você necessita comparar informações.
### Vulnerabilidade
Como o MD5 faz apenas uma passagem sobre os dados, se dois prefixos com o mesmo hash forem construídos, um sufixo comum pode ser adicionado a ambos para tornar uma colisão mais provável. Deste modo é possível que duas strings diferentes produzam o mesmo hash. O que não garante que a partir de uma senha codificada em hash específica consiga-se a senha original, mas permite uma possibilidade de descobrir algumas senhas a partir da comparação de um conjunto grande de hash de senhas através do método de comparação de dicionários.
### Criptografia
Criptografia (em grego: kryptós, "escondido", e gráphein, "escrita") é o estudo dos princípios e técnicas pelas quais a informação pode ser transformada da sua forma original para outra ilegível, de forma que possa ser conhecida apenas por seu destinatário (detentor da "chave secreta"), o que a torna difícil de ser lida por alguém não autorizado. Assim sendo, só o receptor da mensagem pode ler a informação com facilidade. É um ramo da Matemática, parte da Criptologia. Há dois tipos de chaves criptográficas: chaves simétricas(criptografia de chave única) e chaves assimétricas (criptografia de chave pública).
Uma informação não-cifrada que é enviada de uma pessoa (ou organização) para outra é chamada de "texto claro" (plaintext). Cifragem é o processo de conversão de um texto claro para um código cifrado e decifragem é o processo contrário, de recuperar o texto original a partir de um texto cifrado. De fato, o estudo da criptografia cobre bem mais do que apenas cifragem e decifragem. É um ramo especializado da teoria da informação com muitas contribuições de outros campos da matemática e do conhecimento, incluindo autores como Maquiavel, Sun Tzu e Karl von Clausewitz. A criptografia moderna é basicamente formada pelo estudo dos algoritmos criptográficos que podem ser implementados em computadores.
### Chave (criptografia)
Uma chave criptográfica é um valor secreto que modifica um algoritmo de encriptação. A fechadura da porta da frente da sua casa tem uma série de pinos. Cada um desses pinos possui múltiplas posições possíveis. Quando alguém põe a chave na fechadura, cada um dos pinos é movido para uma posição específica. Se as posições ditadas pela chave são as que a fechadura precisa para ser aberta, ela abre, caso contrário, não.
Uma chave é um pedaço de informação que controla a operação de um algoritmo de criptografia. Na codificação, uma chave especifica a transformação do texto puro em texto cifrado, ou vice-versa, durante a decodificação. Chaves são também usadas em outros algoritmos criptográficos, tais como esquemas de assinatura digital e funções hash (também conhecidas como MAC), algumas vezes para autenticação.
Para um algoritmo bem projetado, cifrar o mesmo texto mas com uma chave diferente deverá produzir um texto cifrado totalmente diferente. Igualmente, decifrar o texto cifrado com a chave errada deverá produzir um texto aleatório ininteligível. Se a chave de decriptação for perdida, o dado cifrado praticamente não pode ser recuparado pelo mesmo algoritmo de criptografia.
As chaves usadas na criptografia de chave pública têm uma certa estrutura matemática. Por exemplo, as chaves públicas usadas no sistema RSA são o produto de doisnúmeros primos. Por isso, sistemas de chave pública requerem chaves maiores do que os sistemas simétricos para um nível equivalente de segurança. 3072bits é o tamanho de chave sugerido para sistemas baseados em fatoração e algoritmos discretos inteiros que visam ter segurança equivalente a da cifra simétrica de 128bits. A criptografia de curva elíptica (CCE) pode permitir chaves de tamanhos menores para uma segurança equivalente, mas estes algoritmos são conhecidos há pouco tempo e, pelas estimativas atuais para a dificuldade de se encontrar suas chaves, eles não devem sobreviver.
Recentemente, uma mensagem codificada usando uma chave de 109bits do algoritmo de curva elíptica foi quebrada por força bruta. A regra atual é usar uma chave de CCE com o dobro da segurança da chave simétrica para o nível desejado. Exceto para o one time pad aleatório, a segurança desses sistemas não foi provada matematicamente. Portanto, um ponto fraco teórico poderia fazer de tudo que você codificou um livro aberto. Esta é uma outra razão para se valorizar a escolha de chaves longas.
### A escolha da chave
Para evitar que uma chave seja adivinhada, as chaves precisam ser geradas aleatoriamente e conterem entropia suficiente. O problema de como gerar seguramente chaves verdadeiramente aleatórias é difícil e tem sido encarado de várias formas por vários sistemas criptográficos. Existe um RFC sobre a geração de aleatoriedade (RFC 1750,Randomness Recommendations for Security Recomendações de Aleatoriedade para Segurança]. Alguns sistemas operacionais incluem ferramentas para "coletar" entropia a partir da medição do tempo de certas operações imprevisíveis como os movimentos da cabeça do drive de disco. Para a produção de pequenas quantidades de material, umdado comum é uma boa fonte de aleatoriedade de alta qualidade.
Quando uma senha é usada como chave de codificação, os sistemas de criptografia bem projetados primeiro usam um algoritmo de derivação da chave, que adiciona um "sal" (salt) e o reduz ou o expande para o tamanho de chave desejado, por exemplo, através da redução de uma frase longa a um valor de 128bits apropriado para o uso em umbloco cifrado.
### Alguns algoritmos e sistemas criptográficos
Funções de Hash criptográfico, ou message digest
* MD5
* SHA-1
* RIPEMD-160
* Tiger
Sistemas Free/Open Source
* PGP
* GPG
* SSL
* IPSec / Free S/WAN
Algoritmos assimétricos ou de chave pública
* Curvas elípticas
* Diffie-Hellman
* DSA de curvas elípticas
* El Gamal
* RSA
.
## Interface
Em algumas linguagens de programação, termo interface é uma referência à característica que permite a construção de interfaces que isolam do mundo exterior os detalhes de implementação de um componente de software.
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.
```java=
package entity1;
public interface IConexao {
public void open() throws Exception;
public void close() throws Exception;
}
```
.
```java=
package entity1;
public interface IArquivo extends Conexao {
public void write() throws Exception;
public String read() throws Exception;
}
```
.
```java=
package entity1;
public class ConexaoBanco implements IConexao {
@Override
public void open() throws Exception {
System.out.println("Abrir Conexao Banco de Dados");
}
@Override
public void close() throws Exception {
System.out.println("Fechar Conexao Banco de Dados");
}
}
```
.
```java=
package entity1;
public class ConexaoArquivo implements IArquivo {
@Override
public void open() throws Exception {
System.out.println("Abrir Conexao Arquivo");
}
@Override
public void close() throws Exception {
System.out.println("Fechar Conexao Arquivo");
}
@Override
public void write() throws Exception {
System.out.println("Escrever no Arquivo");
}
@Override
public String read() throws Exception {
return "Ler do Arquivo";
}
}
```
**Sintaxe**
public class ==nome_classe== implements ==nome_interface==
**Onde**
* nome_classe – Nome da classe a ser implementada.
* nome_Interface – Nome da interface a se implementada pela classe.
### Utilização
Um exemplo clássico de utilização de interfaces é o do sistema operacional que, através de uma interface de programação de aplicativos, permite que os programas utilizem os recursos do sistema (memória, CPU e etc) sem que os seus detalhes de implementação sejam conhecidos do programador. Este esquema isola e protege o sistema operacional de eventuais erros cometidos pela aplicação.
Os componentes de software utilizam interfaces padronizadas para criar uma camada de abstração que facilite a reutilização e a manutenção do software. Neste cenário, a interface de um módulo de software deve ser mantida em separado da sua implementação e qualquer outro módulo , que interaja com (cliente de ), deve ser forçado a fazê-lo apenas através da interface. Este mecanismo permite que no caso de uma alteração em , o módulo continue funcionando; desde que a utilização do módulo pelo módulo satisfaça as especificações da interface. (Ver também oprincípio da substituição de Liskov).
Uma interface disponibiliza tipos variados de acesso entre componentes, como por exemplo: constantes, tipos de dado, procedimentos, especificação de exceções e assinaturas de métodos. Em alguns casos é mais apropriado definir as variáveis como parte das interfaces. As interfaces também especificam a funcionalidade disponibilizada através de comentários ou através de declarações lógicas formais (assertions).
### Linguagens
O princípio da interface é um alicerce da programação modular que, por sua vez, é precursora e parte da programação orientada a objeto. Na programação orientada a objeto, a interface de um objeto consiste de um conjunto de métodos que um objeto deve suportar. É importante notar que as variáveis de instância não fazem parte da interface de um objeto pois devem ser acessadas somente pelos "métodos de acesso". Historicamente, as interfaces são derivadas dos arquivos de cabeçalho da Linguagem C (normalmente arquivos com extensão ".h") que separam o contexto sintático de um módulo (ou protótipos de funções) da sua implementação.
Algumas linguagens de programação orientadas a objeto exigem que a interface do objeto seja especificada de forma separada da implementação do objeto, enquanto outras não fazem esta exigência. Por exemplo, em linguagens de programação como Objective-C, a classe do objeto define a sua interface e é declarada em um arquivo de cabeçalho (header em inglês) e, por outro lado, a implementação da classe é mantida em um arquivo chamado de "arquivo fonte". Devido à tipagem dinâmica existente na Objective-C, que permite o envio de mensagens para qualquer objeto, a interface de uma classe é importante para determinar para quais métodos um objeto de uma classe responde.
A linguagem de programação Java, que recebeu influência da Objective-C, utiliza outra abordagem para o conceito de interface, assim como outras linguagens orientadas a objeto, onde a interface especifica um conjunto de métodos ou funcionalidades comuns a um conjunto de classes. Ver interface na linguagem Java.
Algumas linguagens de programação como D, Java e Logtalk, por exemplo, permitem a definição de "hierarquias de interfaces". A linguagem Logtalk também suporta a implementação "privada" e "protegida" dos métodos de uma interface.
A linguagem Eiffel inclui na interface de uma classe as pré e pós-condições para execução dos seus métodos. Esta característica é essencial para a metodologia do projeto por contrato, e pode ser entendida como uma extensão das condições impostas pelos tipos dos argumentos. Estas regras podem ser especificadas na implementação da classe ou em uma classe genérica (classe mãe) que não precisa implementar os seus métodos. Elas são extraídas por processadores da linguagem e podem ser vistas em uma ambiente de desenvolvimento além de gerarem verificações em tempo de execução. A linguagem garante que classes derivadas obedeçam aos contratos definidos nas classes que servem de base.
## 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.
Em orientação a objetos, uma classe é uma estrutura que abstrai um conjunto de objetos com características similares. Uma classe define o comportamento de seus objetos através de métodos e os estados possíveis destes objetos através de atributos. Em outros termos, uma classe descreve os serviços providos por seus objetos e quais informações eles podem armazenar. Classes não são diretamente suportadas em todas as linguagens, e são necessárias para que uma linguagem seja orientada a objetos. Classes são os elementos primordiais de um diagrama de classes.
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.
## Classe Genérica
Generics, ou programação genérica, serve para determinar para o compilador, qual tipo de classe deve ser interpretada. Por exemplo, vamos imaginar que será criada uma classe que irá conter um objeto de alguma outra classe. Para que essa classe possa aceitar qualquer tipo de classe, devemos fazer uso de generics. Generics é indicado como um identificador entre os sinais de maior e menor (<>).
**Criar classes usando generics**
Para criar uma classe usando generics, basta que logo após o nome da classe coloquemos o indicador genérico. Esse indicador genérico é simplesmente uma letra na qual será substituída dentro da classe no momento da execução
## Método 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.
```java=
package entity;
public class Pessoa {
private Integer codigo;
private String nome;
public Pessoa() {
}
public Pessoa(Integer codigo, String nome) {
super();
this.codigo = codigo;
this.nome = 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 this.codigo.equals(p.getCodigo()); // Criando
// o critério de igualdade
}
public Integer getCodigo() {
return codigo;
}
public void setCodigo(Integer codigo) {
this.codigo = codigo;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
}
```
```java=
package main;
import entity.Pessoa;
public class Main {
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
System.out.println(p.equals(p1));
}
}
```
## Interface 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.
```java=
package entity;
public class Pessoa implements Comparable {
private Integer codigo;
private String nome;
public Pessoa() {
}
public Pessoa(Integer codigo, String nome) {
super();
this.codigo = codigo;
this.nome = nome;
}
@Override
public String toString() {
return "Pessoa [codigo=" + codigo + ", nome=" + nome + "]";
}
@Override
public boolean equals(Object obj) {
Pessoa p = (Pessoa) obj;
return this.codigo.equals(p.getCodigo());
}
public Integer getCodigo() {
return codigo;
}
public void setCodigo(Integer codigo) {
this.codigo = codigo;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
@Override
public int compareTo(Pessoa obj) {
// Utilizando a forma abaixo, a ordenação será crescente
return this.codigo.compareTo(((Pessoa)obj).getCodigo());
// Utilizando a forma abaixo, a ordenação será decrescente
// return (((Pessoa)obj).getCodigo()).compareTo(this.codigo);
}
}
```
.
```java=
package main;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import entity.Pessoa;
public class Main {
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();
lista.add(p1);
lista.add(p2);
lista.add(p3);
// Comando para ordenar a lista
// pelo critério feito na classe pessoa
Collections.sort(lista);
System.out.println(lista);
}
}
```
## 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.
* **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.
Apresentação no Java
```java=
try { // tentativa
}
catch (Exception e) { // Apresenta o erro
}
finally{ // Sempre executa
}
```
A código abaixo apresenta o erro na tentativa de dividir um numero por zero e assim parando o projeto.
```java=
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;
}
}
```
```java=
package main;
import entity.Numero;
public class Main {
public static void main(String[] args) {
//Instacia a classe Numero
Numero n = new Numero(10, 0);
int resp;
//Faz o calculo
resp = n.getNum1() / n.getNum2();
//Apresenta o Resultado
System.out.println(resp);
//A divisão irá parar o programa
//e nao irá aparecer o continua
System.out.println("continua");
}
}
```
Agora será utilizado o bloco de instrução try, catch e finally para evitar que o projeto pare.
```java=
package main;
import entity.Numero;
public class Main {
public static void main(String[] args) {
//Instacia a classe Numero
Numero n = new Numero(10, 0);
int resp;
try {
//Faz o calculo
resp = n.getNum1() / n.getNum2();
//Apresenta o Resultado
System.out.println(resp);
} catch (Exception e) {
// Apresenta o Erro by /zero no entanto ,
// // o projeto continua funcionando
// Até o último comando.
System.out.println("Error: " + e.getMessage());
}
finally{
System.out.println("Sempre executa o finally \n ");
}
System.out.println("continua");
}
}
```
## [Junit](https://junit.org/junit5/ "Ir para o site oficial")
O **JUnit** é um framework open-source, criado por Erich Gamma e Kent Beck, com suporte à criação de testes automatizados na linguagem de programação Java.
Esse framework facilita a criação de código para a automação de testes com apresentação dos resultados. Com ele, pode ser verificado se cada método de uma classe funciona da forma esperada, exibindo possíveis erros ou falhas podendo ser utilizado tanto para a execução de baterias de testes como para extensão.
Com **JUnit**, o programador tem a possibilidade de usar esta ferramenta para criar um modelo padrão de testes, muitas vezes de forma automatizada.
O teste de unidade testa o menor dos componentes de um sistema de maneira isolada. Cada uma dessas unidades define um conjunto de estímulos (chamada de métodos), e de dados de entrada e saída associados a cada estímulo. As entradas são parâmetros e as saídas são o valor de retorno, exceções ou o estado do objeto. Tipicamente um teste unitário executa um método individualmente e compara uma saída conhecida após o processamento da mesma.
O **JUnit** permite a realização de testes de unidades, conhecidos como "caixa branca", facilitando assim a correção de métodos e objetos.
Algumas vantagens de se utilizar **JUnit**:
:arrow_right: Permite a criação rápida de código de teste enquanto possibilita um aumento na qualidade do sistema sendo desenvolvido e testado;
:arrow_right: Não é necessário escrever o próprio framework;
:arrow_right: Amplamente utilizado pelos desenvolvedores da comunidade código-aberto, possuindo um grande número de exemplos;
:arrow_right: Uma vez escritos, os testes são executados rapidamente sem que, para isso, seja interrompido o processo de desenvolvimento;
:arrow_right: JUnit checa os resultados dos testes e fornece uma resposta imediata;
:arrow_right: Pode-se criar uma hierarquia de testes que permitirá testar apenas uma parte do sistema ou todo ele;
:arrow_right: Escrever testes com JUnit permite que o programador perca menos tempo depurando seu código;
:arrow_right: JUnit é LIVRE.
A experiência adquirida com o **JUnit** tem sido importante na consolidação do Test Driven Development (desenvolvimento direcionado a testes). Além disso, ele foi adaptado a outras linguagens, tais como C♯ (NUnit), Python, Fortran, e C++.
## :warning: Para adicionar o JUnit ao projeto
:pencil2: Clicar no projeto com o botão direito -> properties
---
:pencil2: Clicar em ==Java Build Path== -> Clicar na aba ==Libraries== -> Clicar no botão ==Add Library==
---
:pencil2: Selecionar o JUNIT -> Clicar em NEXT
---
:pencil2: Selecionar o Junit4 -> clicar em Finish
---
:pencil2: Clicar em Apply and Close
---
## Como gerar um JavaDoc
Javadoc é um gerador de documentação criado pela Sun Microsystems para documentar a API dos programas em Java, a partir do código-fonte. O resultado é expresso emHTML. É constituído, basicamente, por algumas marcações muitos simples inseridas nos comentários do programa. Este sistema é o padrão de documentação de classes em Java, e muitas dos IDEs desta linguagem irão automaticamente gerar um Javadoc em HTML. Ele também provê uma API para a criação de doclets e taglets, que permitem a análise da estrutura de um aplicativo Java. É assim, por exemplo, que o JDiff consegue gerar relatórios de alterações feitas entre duas versões de uma API.
### Tags Javadoc
Os desenvolvedores usam certos estilos de comentários e tags Javadoc ao documentar códigos-fonte. Um bloco de comentário em Java iniciado com /** irá iniciar um bloco de comentário Javadoc, que será incluído no HTML gerado. Uma tag Javadoc começa com um "@" (arroba). Na tabela abaixo, algumas destas tags.
|Tag |Descrição|
--------|---------|
|@author |Nome do desenvolvedor|
|@category |Você pode criar categorias para seus códigos, como “utilidades” ou “maipulação” ou “services”, etç,|
|@deprecated |Marca o método como deprecated. Algumas IDEs exibirão um alerta de compilação se o método for chamado.|
|@exception |Documenta uma exceção lançada por um método — veja também @throws.|
|@link |Possibilita a definição de um link para um outro documento local ou remoto através de um URL.|
|@param |Define um parâmetro do método. Requerido para cada parâmetro.|
|@return |Documenta o valor de retorno. Essa tag não deve ser usada para construtores ou métodos definidos com o tipo de retorno void.|
|@see |Documenta uma associação a outro método ou classe.|
|@since |Documenta quando o método foi adicionado a a classe.|
|@throws |Documenta uma exceção lançada por um método. É um sinônimo para a @exception introduzida no Javadoc 1.2.|
|@version |Exibe o número da versão de uma classe ou um método.|
|{@link XX} |Cria um link para uma classe ou método, o nome da classe ou método deve ser colocado no lugar das letras “XX”|
Para inserir o símbolo @ sem iniciar uma tag Javadoc você pode usar o código de caracter HTML @ e evitar problemas de parsing
### Para gerar o JavaDoc
Clicar em Porject -> Generate Javadoc
Clicar em configure -> Indicar onde se encontra o comando do javadoc -> abrir
Marcar a classe que servira de base para o javadoc -> clicar em browser e indicar onde será salvo os arquivos gerados -> next
Next
Alterar o JRE para 1.8 -> finish
Clicar em yes to all
Na pasta onde foi salvo, só clicar em index.html
Foi criado a documentação em HTML
Clicando no link dados
## Como gerar um Componente JAR (Executável)
Clicar no projeto com o botão direito -> Export
Selecionar Runnable JAR file -> NEXT
Clicar em Browser e indicar onde o arquivo será salvo -> digitar um nome para o arquivo -> SALVAR
Em Launch Configuration, selecionar o arquivo Main do seu projeto
Clicar em FINISH
O arquivo executável foi salvo no diretório indicado
Clicar no arquivo para executá-lo
## DAO (Data Access Object)
.
**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.
A vantagem de usar objetos de acesso a dados é a separação simples e rigorosa entre duas partes importantes de uma aplicação que não devem e não podem conhecer quase que nada uma da outra, e que podem evoluir frequentemente e independentemente. Alterar a lógica de negócio podem esperar apenas a implementação de uma interface, enquanto que modificações na lógica de persistência não alteram a lógica de negocio, desde que a interface entre elas não seja modificada.
* Pode ser usada em uma vasta porcentagem de aplicações;
* Esconde todos os detalhes relativos a armazenamento de dados do resto da aplicação;
* Atua como um intermediário entre a aplicação e o banco de dados;
* Mitiga ou resolve problemas de comunicação entre a base de dados e a aplicação, evitando estados inconsistentes de dados.
No contexto específico da linguagem de programação Java, um objeto de acesso a dados como padrão de projeto de software pode ser implementado de várias maneiras. Pode variar desde uma simples interface que separa partes de acesso a dados da lógica de negócio de uma aplicação até frameworks e produtos comerciais específicos.
O comando Class.forName() é 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 DriverManager.getConnection() 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.
```java=
package persistence;
import java.util.ArrayList;
import java.util.List;
import entity.Pessoa;
public class PessoaDao extends Dao {
public void salvar(Pessoa p) throws Exception {
open();
stmt = con.prepareStatement("insert into pessoa values
(null,?,?)");
stmt.setString(1, p.getNomePessoa());
stmt.setString(2, p.getEmail());
stmt.execute();
stmt.close();
close();
}
public void delete(Pessoa p) throws Exception {
open();
stmt = con.prepareStatement("delete from Pessoa where
idPessoa = ?");
stmt.setInt(1, p.getIdPessoa());
stmt.execute();
stmt.close();
close();
}
public void update(Pessoa p) throws Exception {
open();
stmt = con.prepareStatement("update Pessoa nome = ?,
email = ? where idPessoa = ?");
stmt.setString(1, p.getNomePessoa());
stmt.setString(2, p.getEmail());
stmt.setInt(3, p.getIdPessoa());
stmt.execute();
stmt.close();
close();
}
public Pessoa finallByCod(int cod) throws Exception {
open();
stmt = con.prepareStatement("select * from pessoa where idPessoa
= ? ");
rs = stmt.executeQuery();
Pessoa p = null;
if (rs.next()) {
p = new Pessoa();
p.setIdPessoa(rs.getInt("idPessoa"));
p.setNomePessoa(rs.getString("nomePessoa"));
p.setEmail(rs.getString("email"));
}
close();
return p;
}
public List findAll() {
try {
open();
stmt = con.prepareStatement("select * from pessoa");
rs = stmt.executeQuery();
List lista = new ArrayList();
while (rs.next()) {
Pessoa p = new Pessoa();
p.setIdPessoa(rs.getInt("idPessoa"));
p.setNomePessoa(rs.getString("nomePessoa"));
p.setEmail(rs.getString("email"));
lista.add(p);
}
close();
return lista;
} catch (Exception e) {
System.out.println(e.getMessage());
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 script.sql.
**script.sql**
```sql=
# O símbolo # serve para comentar no script.sql
# 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)
);
```
A Camada de modelo encontra-se a classe de dados que nesse exemplo é Pessoa.
```java=
package entity;
public class Pessoa {
private Integer idPessoa;
private String nomePessoa;
private String email;
public Pessoa() {
}
public Pessoa(String nomePessoa, String email) {
super();
this.nomePessoa = nomePessoa;
this.email = email;
}
public Pessoa(Integer idPessoa, String nomePessoa, String email) {
super();
this.idPessoa = idPessoa;
this.nomePessoa = nomePessoa;
this.email = email;
}
@Override
public String toString() {
return "Pessoa [idPessoa=" + idPessoa + ", nomePessoa="
+ nomePessoa + ", email=" + email + "]";
}
public Integer getIdPessoa() {
return idPessoa;
}
public void setIdPessoa(Integer idPessoa) {
this.idPessoa = idPessoa;
}
public String getNomePessoa() {
return nomePessoa;
}
public void setNomePessoa(String nomePessoa) {
this.nomePessoa = nomePessoa;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
}
```
```java=
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@gmail.com");
Pessoa p2 = new Pessoa(null, "joao", "joao@gmail.com");
PessoaDao pd = new PessoaDao();
try {
//Comando para gravar no banco;
pd.create(p1);
pd.create(p2);
//Comando para listaTodos
System.out.println(pd.findAll());
//Comando para alterar uma pessoa;
// 1º Passo
//Busca pelo Codigo
// 2 -> é a chave primaria de pessoa no banco
Pessoa pessoa = pd.finallByCod(2);
System.out.println("pessoa:" + pessoa);
pessoa.setEmail("joao2@gmail.com");
// 2º Passo
//Alterar o usuario 2
System.out.println("pessoa:" + pessoa);
pd.update(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 : pd.findAll()){
System.out.println(p);
}
//Comando para deletar uma pessoa;
//1º Passo : buscar o Codigo
Pessoa pessoa1 = pd.finallByCod(2);
//2º Passo
pd.delete(pessoa1);
//Comando para listaTodos
System.out.println(pd.findAll());
} catch (Exception e) {
System.out.println("Error: " + e.getMessage());
}
}
```
## Serialversion
.
A serialização em Java é o processo no qual a instância de um objeto é transformada em uma sequência de bytes e é útil quando precisamos enviar objetos pela rede, salvar no disco, ou comunicar de uma JVM com outra. Isso porque o estado atual do objeto é “congelado” e na outra “ponta” nós podemos “descongelar” este objeto sem perder nenhuma informação.
Para habilitar a serialização de terminada classe você deve explicitamente implementar a interface Serializable. Esta interface é apenas de marcação, pois não tem nenhum método a ser implementado, serve apenas para que a JVM saiba que aquela determinada Classe está hábil para ser serializada. Veja um exemplo simples na listagem 1.
Serializar um objeto, dentro da plataforma Java, significa converter o estado atual dele em um formato padrão e depois disponibilizá-lo em um stream de bytes que poderá ser escrito em disco ou transmitido. Repare que a palavra serializar, dentro do Java, é um pouco mais do que “entregar em partes” – que seria a definição da mesma. É preciso que essas partes tenham uma estrutura padronizada para que seja possível a desserialização.
### O que é o serialVersionUID?
Esse é um atributo utilizado para controlar explicitamente a compatibilidade entre o .class usado para serializar e o .class que será utilizado na desserialização. O controle é necessário porque um .class pode ter sofrido alterações e ainda assim se manter compatível com sua versão anterior. O ideal, claro, é utilizar as mesmas versões de .class, mas nem sempre isso será possível.
Aí que entra o serialVersionUID.
Ele é o recurso que usamos para dizer ao Java que um objeto serializado é compatível ou não com o .class utilizado para desserializar. Inclusive, sempre que temos uma classe estendendo a interface java.io.Serializable esse atributo é criado, mesmo que a implementação venha por alguma superclasse. Caso ele não esteja declarado por você (explicitamente) o Java irá declará-lo no momento da compilação. Caso você não informe o atributo serialVersionUID, o Java o fará por você na hora em que for compilar e para gerar o valor de serialVersionUID são levados em consideração alguns aspectos de estrutura da classe:
* o nome da classe e seus modificadores;
* o nomes das interfaces que a classe implementa;
* os atributos e seus modificadores;
* e algumas outras coisas como você pode conferir na documentação do processo de serialização.
Esses elementos são organizados, então é aplicado um algoritmo de hash que depois vira o valor do atributo serialVersionUID. Qualquer alteração nesses elementos acarretará em um valor diferente.
## Programação Funcional
É um paradigma de programação, tal como Programação Orientado a Objetos(POO) e Programação Imperativa (existem outros paradigmas, mas esses são os mais famosos). Entende-se como paradigma uma forma de fazer algo. Ou seja, paradigma de programação é o nome que se dá a maneira como se programa, a orientação que seus códigos irão ter. POO, por exemplo, vai me ensinar a modelar meus códigos e algoritmos pensando em entidades que possuem características e comportamentos, vulgo objetos. Em Imperativa, vamos dar ao nosso programa uma sequência de passos para resolver determinado problema.
De maneira simples: código funcional é um código composto de múltiplas funções que se compõem para resolver um problema. Pense da seguinte forma: eu tenho um dado de entrada e preciso transformá-lo em um dado de saída. Usando PF eu vou abstrair as lógicas de transformações do meu código em funções, e usá-las no momento oportuno para transformar este meu dado.
### Imutabilidade, pra que te quero?
Lá vai a primeira orientação: não use variáveis, use constantes! Sim, isso mesmo que eu falei, você não vai ter código com uma pancada de variáveis, você vai ter um código mais sucinto com constantes que, via de regra, não irão mudar! Parece coisa de maluco, mas vou te dizer alguns motivos de porquê um código imutável pode ser tão bom.
A imutabilidade faz sentido dentro da programação funcional pelo seu viés matemático. Nela, um número sempre será aquele valor, independente de onde esteja ou como está sendo usado. É importante também entender que nas expressões matemáticas, para um mesmo valor passado a uma variável, teremos o mesmo retorno da função. Ele nunca muda. Se você tem uma expressão como f(x) = x + 2, você pode passar o número 3 quantas vezes quiser, esta função sempre retornará 5. Um último ponto é que o número 3 passado para x, não irá mudar seu valor, ou seja, ele permanece inalterado após o seu uso na função.
### Abstração acima de tudo!
Abstração é a capacidade de separar o essencial do que não é essencial.
Primeiramente, o que seria, em termos de código, uma abstração? Seria a implementação de uma função para um determinado bloco de código a ser utilizado e reutilizado. Quais as vantagens da abstração?
* Primeiro, você estará reaproveitando código. Menos código com mais informações. Isso é bom.
* O processo todo em que as funções foram abstraídas irão fazer sentido para você. Isso, alinhado com um bom nome para as funções, deixarão o seu código muito legível e de fácil compreensão.
### Funções, funções, funções...
Não é a toa que programação funcional é a programação “orientada a funções”. O conceito de função matemática permeia este paradigma, como expliquei quando falei de imutabilidade. Agora, se torna necessário eu trazer alguns conceitos importantes quando falamos de funções.
### Funções puras
Bem, o conceito de funções puras tem tudo a ver com a não existência de efeitos colaterais. Funções puras são funções que não modificam o escopo ao redor delas. Quando eu aprendi um pouco da Linguagem C, aprendi um conceito muito interessante: ponteiro. E aprendi que é através deles que as funções em C podiam modificar variáveis fora de seu escopo interno. Bem, nós já vimos um exemplo de uma função impura e também um exemplo de uma função pura. Mas quais os princípios por trás? Uma função pura:
* Recebe ao menos um parâmetro e trabalha com ele.
* Ela retorna alguma coisa. É interessante que uma função, como nos ensinam, via de regra, é uma sequencia de procedimentos a serem executados. Até ai, tudo bem, porem, em programação funcional uma função sempre deve retornar um valor. Por que? Encadeamento de operações.
## Map
interface pública Mapa <K, V>
Um objeto que mapeia chaves para valores. Um mapa não pode conter chaves duplicadas; cada chave pode mapear no máximo um valor.
Essa interface toma o lugar da classe Dictionary , que era uma classe totalmente abstrata em vez de uma interface. A interface Map fornece três visualizações de coleção , que permitem que o conteúdo de um mapa seja exibido como um conjunto de chaves, coleção de valores ou conjunto de mapeamentos de valor-chave. A ordem de um mapa é definida como a ordem em que os iteradores nas visualizações de coleção do mapa retornam seus elementos. Algumas implementações de mapa, como a classe TreeMap , fazem garantias específicas quanto ao seu pedido; outros, como a classe HashMap , não.
>Nota: grande cuidado deve ser exercido se objetos mutáveis forem usados como chaves de mapas. O comportamento de um mapa não é especificado se o valor de um objeto for alterado de uma maneira que afete as comparações de iguais, enquanto o objeto é uma chave no mapa. Um caso especial desta proibição é que não é permitido que um mapa se contenha como uma chave. Embora seja permitido que um mapa se contenha como um valor, recomenda-se extrema cautela: os métodos equals e hashCode não são mais bem definidos em tal mapa.
>
[Fonte](https://docs.oracle.com/javase/6/docs/api/java/util/Map.html)
Os objetos “Map” confiam seus dados em um algoritmo hash (hash code). Esse algoritmo transforma uma grande quantidade de dados em uma pequena quantidade de informações, sendo que o mecanismo de busca se baseia na construção de índices.
Um exemplo prático pode ser usado como uma lista telefônica onde a letra seria o índice a ser procurado, para conseguir achar mais fácil o nome desejado.
Essa interface é um objeto que mapeia valores para chaves, ou seja, através da chave consegue ser acessado o valor configurado, sendo que a chave não pode ser repetida ao contrário do valor, mas se caso tiver uma chave repetida é sobrescrito pela última chamada. Também faz parte do pacote java.util e não possui métodos da interface Collection.
.
.
###### tags: `java` `apostila` `basico`
Sign in with Wallet
Connect another wallet