Classe cliente

Prévia do material em texto

Em Java, cada objeto é alocado em um espaço da memória. No exemplo da figura abaixo, embora c1 e c2 guardem valores iguais, eles são objetos diferentes, pois estão em espaços diferentes da memória.
Classe cliente
Classe Conta
Classe Programa
PERGUNTA: Mas e se dentro do meu código eu não desse new em Cliente e tentasse acessá-lo diretamente?
minhaConta.titular.nome = "Manoel";
RESPOSTA: Quando damos new em um objeto, ele inicializa os valores dos objetos com valor default: 
· 0 para números,
· False para booleano e
· Nulo para referências. 
Null é uma palavra-chave em Java que indica uma referência a nenhum objeto.
Se, tentarmos acessar um atributo ou método de alguém que está referenciando um valor null, receberemos um erro durante a execução.
Percebe-se, então, que o new não apresenta um efeito cascata, a menos que você dê um valor default na classe Cliente, ou use construtores.
Vamos usar um construtor, ele inicializará todos os valores com default: 
 Classe Conta:
Classe Programa:
Ao usar o construtor na classe conta, quando usarmos o new Conta, sempre haverá um new Cliente.
Com isso, toda nova conta criada já terá um novo cliente associado sem a necessidade de instanciá-lo logo em seguida da instanciação da conta.
MODIFICADOR DE ACESSO
Na POO, a prática adotada é deixar os atributos como privados, e os métodos como públicos.
E QUANDO NÃO HÁ MODIFICADOR DE ACESSO?
Até agora, tínhamos declarado variáveis e métodos sem nenhum modificador como private e public. Quando isso acontece, o seu método ou atributo fica em um estado de visibilidade intermediário entre o private e o public, que veremos mais para frente, no capítulo de pacotes.
ENCAPSULAMENTO
Ao usar modificadores de acesso, estamos usando a ideia de encapsular, isto é, ocultar todos os membros de uma classe (como vimos acima), além de esconder como funcionam as rotinas (no caso, métodos) do nosso sistema.
INTERFACE DA CLASSE: conjunto de métodos públicos de uma classe.
GETTERS E SETTERS: 
Como mostrar o saldo de uma conta se ele está como privado? Para isso, usamos métodos. 
Os métodos Get e Set são usados para retornar e mudar, respectivamente, os valores de um atributo privado. 
OBSERVAÇÃO – Padrões GoF: É uma má prática criar uma classe e, logo em seguida, fazer getters e setters para todos seus atributos. Você só deve criar um getter ou setter se tiver a real necessidade.
OBSERVAÇÃO: No caso de atributos booleanos, pode-se usar, no lugar do get, o sufixo is. Desse modo, caso tivéssemos um atributo booleano ligado em vez de getLigado, poderíamos ter isLigado.
CONSTRUTOR
· Construtor não é um método.
· É uma rotina de inicialização chamada sempre que um novo objeto é criado.
· Quando você não declara nenhum construtor na sua classe, o Java cria um para você. Esse construtor é o construtor default. Ele não recebe nenhum argumento e o seu corpo é vazio.
· A partir do momento que você declara um construtor, o construtor default não é mais fornecido. 
· Um construtor pode receber um argumento, inicializando, assim, algum tipo de informação:
class Conta {
String titular;
int numero;
double saldo;
// construtor
Conta(String titular) {
this.titular = titular;
}
}
JAVA BEAN
Quando criamos uma classe com todos os atributos privados, seus getters, setters e um construtor vazio (padrão), na verdade, estamos criando um Java Bean (mas não confunda com EJB, que é Enterprise Java Beans).
ATRIBUTOS DE CLASSE
· São atributos compartilhados entre objetos.
· Atributos de classe = atributos estáticos.
· Atributos estáticos pertencem à classe e não aos objetos.
· Métodos estáticos são usados para acessar esses atributos.
Para acessarmos um atributo estático, não usamos a palavra-chave this, mas, sim, o nome da classe.
Exemplo:
PERGUNTA: Já que o atributo é privado, como podemos acessar essa informação a partir de outra classe?
RESPOSTA: Precisamos de um getter para ele!
Na classe principal chamamos assim:
	int totalDeContas = Conta.getTotalDeContas();// Chamando o atributo de classe
Cada vez que criar uma nova conta, ou seja, um novo objeto, o totalDeContas será atualizado. 
MÉTODOS ESTÁTICOS 
Os métodos estáticos operam sobre os atributos estáticos (atributos de classe), ou que não realizam operação alguma sobre os atributos dos objetos. 
Um método estático não é do contexto do objeto, mas, sim, de sua classe. Assim como no caso de atributos estáticos, também não é necessário criar o objeto da classe para que se possa usar o método.
PADRÃO DA NOMENCLATURA DOS PACOTES
O padrão da Sun para dar nome aos pacotes é relativo ao nome da empresa que desenvolveu a classe:
br.com.nomedaempresa.nomedoprojeto.subpacote
br.com.nomedaempresa.nomedoprojeto.subpacote2
br.com.nomedaempresa.nomedoprojeto.subpacote2.subpacote3
ACESSO AOS ATRIBUTOS, CONSTRUTORES E MÉTODOS
Os modificadores de acesso existentes em Java são quatro: 
Default: permite acesso para classes e membros do mesmo pacote.
Public: Para qualquer classe em qualquer pacote.
Private: Torna um membro acessível apenas para a classe que o contém.
Protected: 
· Um membro é acessível para classes do mesmo pacote e para classes que estendem essa classe através da herança (ainda que estejam em pacote diferente). 
· Os membros herdados NÃO são acessíveis a outras classes fora do pacote em que foram declarados.
OBSERVAÇÃO: Uma classe só pode ser pública ou default (acessível somente no mesmo pacote). 
Em Java, temos dois níveis de modificadores de acesso:
Nível superior: 
· Aplicado às classes – public e default 
Nível de membro:
· Aplicado à métodos e atributos – private, public, protected, default
CRIAR JAR:
Um JAR (Java ARchive) é um arquivo compactado, usado para distribuir um conjunto de classes Java; 
É usado para armazenar classes compiladas e metadados associados que podem constituir um programa.
Arquivos .jar podem ser criados e extraídos usando o utilitário "jar" da JDK. Ferramentas de compressão (como o WinZip) também podem criar arquivos .jar.
Para criar o jar pelo CMD, acessar a pasta do projeto e digitar o comando:
Para fazer isso pelo CMD, é preciso que a variável de ambiente esteja configurada.
EXEMPLO:
Variável de ambiente:
JAVA_HOME: C:\Arquivos de programas\Java\jdk1.7.0_02
CLASSPATH: JAVA_HOME
Paht: C:\Arquivos de programas\PC Connectivity Solution;%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem;C:\gpt\bin;%JAVA_HOME%\bin;%JAVA_HOME%\lib
Para gerar o Jar pelo Eclipse, ir em ‘Export’:
Seguir os passos das telas seguintes e finalizar.
HERANÇA, REESCRITA E POLIMORFISMO
Herança: Uma classe herda atributos ou comportamentos de uma outra classe (classe mãe).
Em um banco podemos ter funcionários, precisamos de uma classe:
Podemos ter uma classe gerente, porém, um gerente é um funcionário, por isso, precisando criar uma classe que tenha todos os atributos da classe funcionário, e tenha seus próprios atributos, pois um gerente realiza atividades diferentes de outros funcionários comuns.
Exemplo da classe gerente: 
A classe funcionário é a classe mãe ou superclasse. 
A classe gerente é a classe filha ou subclasse.
Uma classe pode ter várias filhas, mas somente uma mãe, essa é a herança simples do Java. 
Observação: Herança simples = uma classe pode ter várias filhas, mas somente uma mãe.
REESCRITA:
Reescrita: é reescrever um comportamento herdado da classe mãe.
A classe gerente herda todo comportamento geral da classe Funcionário. Se quisermos fazer um comportamento diferente para algum método herdado, usamos a reescrita.
Exemplo:
Todo fim de ano, os funcionários do banco, recebem uma gratificação, 10% para funcionários comuns, e 15% para gerentes.
Se criarmos um método de bonificação na classe Funcionario, o Gerente também vai receber 10% de aumento, sendo que o correto é receber 15%.
Para isso, podemos reescrever esse método na classe Gerente.
No Java, quando herdamos um método, podemos alterar seu comportamento. Podemos reescrever (reescrever, sobrescrever, override) esse método:Há como deixar explícito no seu código que determinado método é a reescrita de um método da classe mãe dele. Podemos fazê-lo colocando @Override em cima do método.
INVOCANDO O MÉTODO REESCRITO
Invocar método reescrito: a classe filha chama um método da classe mãe e adiciona algo ‘a mais’ no método.
Exemplo: precisamos calcular um bônus extra de um Gerente, devemos fazer igual ao cálculo de um Funcionário, porém adicionando R$ 1000: 
public class Gerente extends Funcionario {
int senha;
int numeroDeFuncionariosGerenciados;
public double getBonificacao() {
return this.salario * 0.10 + 1000;
}
// ...
}
Aqui teríamos um problema: o dia que o getBonificacao do Funcionario mudar, precisaremos mudar o método do Gerente a fim de acompanhar a nova bonificação. 
Para evitar isso, o getBonificacao do Gerente pode chamar o do Funcionario utilizando a palavra-chave super.
public class Gerente extends Funcionario {
int senha;
int numeroDeFuncionariosGerenciados;
public double getBonificacao() {
return super.getBonificacao() + 1000;
}
// ...
}
REESCRITA: pego um método e mudo ele na classe filha. 
INVOCAR: adiciona algo a mais no método, usa a palavra-chave SUPER para chamar o método na classe filha.
Polimorfismo 
Polimorfismo: característica da POO que permite que diferentes objetos respondam a mesma mensagem cada um à sua maneira. 
RESUMO: Capacidade de um objeto assumir diferentes formas. 
Vamos ver o exemplo abaixo:
· Pessoa é a classe mãe
· PessoaFisica e PessoaJuridica são classes filhas.
Uma pessoa pode ser pessoa física, como pode ser pessoa jurídica. 
Quando trabalhamos com uma variável do tipo Pessoa (que é uma superclasse), podemos fazer esta variável receber um objeto do tipo PessoaFisica ou PessoaJuridica, por exemplo:
Pessoa fisica = new PessoaFisica();
Pessoa juridica = new PessoaJuridica();
Com isso, podemos dizer que polimorfismo é a capacidade de um objeto ser referenciado de diversas formas diferentes e com isso realizar as mesmas tarefas (ou chamadas de métodos) de diferentes formas.
Um exemplo do uso do polimorfismo utilizando a classe Pessoa, seria todas as subclasses sobrescreverem o método public String getNome().
Classe Abstrata
O que é classe abstrata: é uma classe especial que não pode ser instanciada. Ela contém métodos genéricos que podem ser usados por outras classes.
Em Java, temos um tipo especial de classe chamado classe abstrata: É um tipo de classe especial que não pode ser instanciada, apenas herdada. 
· A classes abstratas servem como modelos para suas classes derivadas. 
· As classes derivadas das classes abstratas são conhecidas como classes concretas.
· Classes concretas: são classes derivadas (filhas) de uma classe abstrata.
· Métodos abstratos: Estão presentes somente em classes abstratas.
· Métodos abstratos não possuem implementação.
· Métodos abstratos são métodos genéricos a serem implementados nas classes filhas.
· Uma classe abstrata não pode ser instanciada. 
Classe abstrata -> compartilha métodos genéricos com as classes derivadas concretas
Os métodos abstratos são implementados nas classes derivadas concretas
CLASSE TELA:
package br.com.tecnologando.Aula08ClasseAbstrata;
/**
* Classe abstrata que possui os métodos básicos para
* as telas do computador de bordo de um veiculo.
* Classe abstrata não pode ser instancia. Seus métodos abstratos são usados por suas classes derivadas concretas.
*/
public abstract class Tela{
private String titulo;
public void setTitulo(String titulo) {
this.titulo = titulo;
}
public abstract String obterInformacao(); //Aqui temos somente a assinatura do método, sua implementação se dá pela classe concreta (classe derivada).
public void imprimir() {
System.out.println(this.titulo);
System.out.println("\t" + obterInformacao());
}
}
CLASSE TELA KILOMETRAGEM:
package br.com.tecnologando.Aula08ClasseAbstrata;
/**
* Tela que mostra a kilometragem percorrida por um veiculo.
*/
public class TelaKilometragem extends Tela {
/* Atributo que guarda o valor da km atual do veiculo. */
int km = 0;
/**
* Construtor que iniciliza o titulo da tela.
*/
public TelaKilometragem() {
/* Atribui o valor do titulo desta tela. */
super.setTitulo("Km Atual"); //Super invoca método da classe mãe
}
/**
* Implementa o método abstrato da classe Tela,
* neste método buscamos a km atual do veiculo.
* 
* @return Texto com a km atual.
*/
@Override
public String obterInformacao() {
km += 10;
return String.valueOf(km) + " km";
}
}}
Outro exemplo de implementação de classe abstrata:
Seria, criar uma classe abstrata chamada Conta, com métodos genéricos, e criar classes concretas (derivadas) chamadas conta corrente e conta poupança, implementando métodos específicos.
As classes abstratas são importantes quando não queremos criar um objeto a partir de uma classe “geral”, apenas de suas “subclasses”. No exemplo da conta, não queremos criar uma conta a partir da classe geral, e sim, uma conta poupança ou corrente.
INTERFACES
Interface é um tipo de classe que contém especificações para outras classes. 
· A classe que implementa uma interface, é obrigada a chamar todos os métodos da interface.
· Posso colocar atributos na interface, mas os atributos precisam ser inicializados.
· Os atributos e métodos das interfaces devem ter modificadores public, static ou final (para constantes). Entretanto, o ideal é deixar os atributos nas classes e não na interface.
Por várias vezes, precisamos especificar um conjunto de métodos que um grupo de classes deverá, obrigatoriamente, implementar. Para atingir este efeito, utilizamos as interfaces.
Basicamente, uma interface define um “contrato” a ser seguido por outras classes. Este contrato é composto por cláusulas, que descrevem determinados comportamentos que este grupo de classes deverá seguir.
Por “obrigar” que as classes que implementem uma interface, também implementem seus métodos, as interfaces apenas definem as assinaturas dos métodos (tipo de retorno, nome e parâmetros). 
A partir daí, é obrigação da classe que quer implementar esta interface, utilizar esta assinatura e implementar seus métodos. Estes métodos, assim como nas classes abstratas, devem ser abstratos.
Observação: Um método abstrato é algo que você promete implementar em uma subclasse. 
Além disso, por não ser considerada uma classe, as interfaces não possuem construtores e, por isso, não podem ser instanciadas, como as classes abstratas.
EXEMPLOS:
Observação: Não se usa muito o uso de atributos dentro de interface, geralmente, se usa dentro da própria classe. Por exemplo, o ideal, seria que o atributo boolean vivo fosse na classe Animal. 
DIFERENÇA INTERFACES E CLASSES ABSTRATAS:
As classes abstratas e interfaces possuem algumas características semelhantes: 
· Não podem ser instanciadas, 
· Possuem métodos abstratos que obrigam as outras classes a implementá-los. 
Porém elas não servem para o mesmo propósito.
Interfaces: Quando utilizamos as interfaces, estamos definindo um conjunto de assinatura de métodos que outras classes devem obrigatoriamente implementar. 
Classes abstratas: as classes abstratas servem como uma base para as subclasses não precisar se preocupar com o comportamento padrão, apenas com suas características e comportamentos pessoais.
· Sempre que precisarmos definir um conjunto de métodos que devem ser implementados por um grupo de classes, utilizamos as interfaces.
· Se precisarmos determinar uma classe base para outras classes, que herdarão seus atributos e métodos e esta classe não deva ser instanciada, utilizamos as classes abstratas.
EXCEÇÕES 
A exceção em Java, para tratamento de erros, pode ser try/cacth ou FileNotFoundException
Exemplos:
FINALLY
Os blocos try e catch podem conter uma terceira cláusula chamada finally, a qual indica o que deve ser feito após o término do bloco try ou de um catch qualquer.
ARRAYS E COLEÇÕES EM JAVA
Arrays é uma coleção de variáveis.
· int[] num= new int[5]; //array com 5 elementos
O primeiro elemento sempre começa na posição zero (no exemplo acima, o índice vai do 0 ao4).
public class CursoJava {
public static void main(String[] args) {
int[] num= new int[5]; //array com 5 elementos
num[0]=52;
num[1]=100;
num[2]=3;
num[3]=15;
num[4]=527;
for(int i=0;i<num.length;i++) { //num.length pega o último índice do array
System.out.printf("%d%n", num[i]);
} 
}
}
Ou podemos fazer:
public class CursoJava2 {
public static void main(String[] args) {
final int tamanho=5;
int[] num= new int[tamanho]; //array com 5 elementos
num[0]=52;
num[1]=100;
num[2]=3;
num[3]=15;
num[4]=527;
for(int n:num) { 
System.out.printf("%d%n", n);
} }}
PASSAGEM POR VALOR E POR REFERÊNCIA
Em Java, não tem como especificar se a passagem em uma função é por valor ou por referência. Basicamente, toda passagem é por valor, com exceção de arrays.
Se eu passar um array para uma função, então teremos uma passagem por referência. Em Java não tem como especificar que uma variável comum será repassada por referência. 
Para mostrar os valores de aprovados e reprovados corretamente, podemos fazer:
1° Colocar os dois system.out.println dentro da função conferirNotas e apagar do main principal. 
2° Ou, o mais ideal, criar um array para aprovados e reprovados.
QUANTOS PARÂMETROS UMA FUNÇÃO PODE TER?
Geralmente, ao criarmos uma função, passamos um número definido de parâmetros. Exemplo:
public static int soma(n1,n2) { 
int resultado=0;
for(int v:n) {
resultado= resultado+v;
}
return resultado;
}
Porém, podemos passar mais parâmetros para a função:
Métodos para trabalhar com array:
Sort: serve para ordenar o array, do menor para o maior.
Fill: preenche o array.
ArrayCopy: Copia um array para o outro.
Exemplo: System.arraycopy(num, 0, num2, 0, num.length);
· Num é o array que será copiado, 
· 0 é a posição inicial que será copiada do array num, 
· num2 é o array destino, que receberá a cópia,
· 0 é a posição inicial do array num2,
· E num.length é a quantidade de elementos que quero copiar. Length retorna o tamanho do array.
Equals: Compara dois arrays.
BinarySearch: usado para encontrar um elemento em uma matriz classificada. Observação: a matriz precisa estar ordenada / classificada.
PASSANDO PARÂMETROS PARA O PROGRAMA
Observe o código abaixo:
Não tem valores passados no programa. No caso, iremos passar os valores ao executar o programa pelo CMD:
ATENÇÃO: O public static void main(String args[]) { - O String args[] pode receber valores ao executar o programa pelo CDM.
MATRIZES
O que é matriz? Uma matriz é um array de duas dimensões, com linhas e colunas.
A saída será uma matriz com 3 linhas e 5 colunas preenchida de números aleatórios:
STRINGS - MÉTODOS PARA TRABALHAR COM STRINGS:
Length = informa o tamanho do texto em caracteres (considera espaço em branco)
Exemplo: int tamanhoDoTexto=texto.length();
charAt = pega o caractere de uma determinada posição.
Exemplo: 
String texto_s = new String(“CFB Cursos”);
char c;
c=texto_s.charAt(2); 
//Qual caractere está na posição 2? (Lembrando que o índice começa em zero)
System.out.println(c);
//A saída será B , pois em CFB Cursos, a letra B está na posição 2
getChars = Copia caracteres de uma string para outra string
Exemplo: texto_s.getChars(a, b, texto, c);
· A=posicao inicial da string ou array de origem
· B=Posição final da origem
· Texto = o array ou string que vai receber o conteúdo (Deve ser texto do tipo char)
· C= A partir de qual posição o array vai receber o conjunto de caracteres
Exemplo de código:
equals ou == 
Para Strings, o ideal é usar o equals. EXEMPLO:
equalsIgnoreCase
Quando fazemos texto1.equals(texto2), se o texto1 for Eliane, e o texto2 for eliane, o equals vai considerar os dois textos diferentes, pois, um começa com letra maiúscula e outro com letra minúscula. 
Para comparar o texto ignorando as letras minúsculas ou maiúsculas, devemos usar o equalsIgnoneCase:
if(texto1.equalsIgnoreCase(texto2))
compareTo
Faz a comparação de duas strings:
· Se elas forem iguais, vai retornar zero, 
· Se a primeira string for menor que a segunda retorna um número negativo
· Se a primeira string for maior retorna um número positivo
CompareTo retorna um valor inteiro. Também podemos usar compareToIgnoreCase, para ignorar letras maiúsculas. 
regionMatches permite comparar parte de uma string. Exemplo de uso:
if(s1.regionMatches(true, 0, s2, 0,3))
No primeiro parâmetro, devemos informar se letras maiúsculas e minúsculas serão ignoradas (true), ou se não serão ignoradas (false).
No segundo parâmetro, é o índice que vamos começar na string s1 para comparar, no caso, estamos começando do índice zero.
No terceiro parâmetro é o nome da string que vamos comparar com a string s1. No caso, é a s2.
No quarto e quinto parâmetro, é o primeiro e último índice da s2 que será avaliada.
startsWith: Testa se uma string começa com um determinado caractere. É case sensitive.
endsWith: Testa se uma string termina com um determinado caractere. É case sensitive.
indexOf: Vai localizar o caractere dentro de uma string, e retornar a posição desse caractere. Retorna um inteiro. É case sensitive.
substring: Retorna parte de uma substring.
concat: Concatena / junta duas strings.
ATENÇÃO:
New String x String literal
String s1 = new String("Eliane"); //objeto
String s2 = "Eliane"; //String literal
Primeiro: quando declaramos uma String Object - string criada a partir do operador new(), como por exemplo:
String obj = new String("Java"), 
Estamos criando um novo objeto String em um lugar chamado heap memory.
O que é heap memory? é o lugar onde a JVM deixa guardado todos os objetos que vão sendo criados ao decorrer do nosso programa.
Segundo: quando declaramos uma String Literal, ou seja, uma string como:
String texto = "Java",
É realizada busca pela string "Java" no string pool.
O que é string pool? um lugar onde as strings são armazenadas. 
Então, toda vez que uma string literal é criada, a JVM verifica se essa string já existe na string pool. Caso ela exista, é retornado à referência para a string, mas caso ela não exista, uma nova string object é inicializada e adicionada na string pool para que futuramente, se outra string literal for criada, não seja necessário inicializar um novo objeto e possamos pegá-la diretamente da string pool.
Aqui temos uma imagem que ilustra isso:
Replace: Vai substituir determinado caractere em uma string. É case sensitive.
toLowerCase: Coloca os caracteres minúsculos, não é case sensitive.
toUpperCase: Coloca os caracteres maiúsculos, não é case sensitive.
trim: corta / remove espaços no início ou final de uma String. 
toCharArray: Converte uma string em um array de caracteres.
split:  quebra uma String em várias substrings a partir de um caracter definido por você.
ARQUIVOS E DIRETÓRIOS
Primeiro, diretório:
Segundo, arquivo:
Abrindo um arquivo em Java:
Substituindo um arquivo:
Observação: No código acima, ao executar, não vai aparece mensagem nenhum no console, mas, sim, irá substituir o arquivo no diretório especificado.
STACK, PILHAS EM JAVA
Pilha = primeiro a entrar, último a sair.
Fila = primeiro a entrar, primeiro a sair.
Exemplo de pilha (Stack):
FILA – QUEUE
Pilha = primeiro a entrar, último a sair.
Fila (FIFO) = primeiro a entrar, primeiro a sair.
O topo da fila será o Honda, que foi o primeiro a entrar.
Observações:
	
	PILHA
	FILA
	Adicionar elemento
	Push
	Add
	Pegar o primeiro elemento
	Peek
	Peek
	Pegar o primeiro elemento e o retira da pilha ou fila
	Pop
	Poll
	Ver se está vazio
	Empty ou isEmpty
	isEmpty
	Limpar
	Clear
	Clear
HASHMAP
Essa coleção trabalha com elementos do tipo chave valor (em pares). Teremos uma chave associado ao valor, ou valor associado a uma chave.
Saída:
HASHSET
Essa coleção armazena valores únicos. Não pode ter valores repetidos. Mesmo inserindo valores repetidos, ela não vai armazenar os valores repetidos.
Não vai dar erro quando a gente armazena valores duplicados, simplesmente vai ignorar valores duplicados e inserir valores únicos.
Saída:
Outros métodos que podemos usar nessa coleção: clear, remove, equals, isEmpty dentre outras.
ITERATOR
É um elemento presente na maioriadas coleções (ArrayList, HashMap, HashSet).
É o elemento que vai trabalhar os dados.
Saída:
LAMBDA
Há muito tempo atrás, os desenvolvedores precisavam:
· Criar interfaces
· Definir métodos para essas interfaces
· E depois implementar esses métodos com classes anônimas
O Java 8 introduziu as funções lambda, que são compactas, eliminando a necessidade de criar classes ou interfaces de forma separada. 
O que são interfaces funcionais:
São interfaces especiais que possuem apena um método. Dentro do próprio Java já existem algumas interfaces funcionais criadas. 
Interfaces Funcionais são todas as interfaces que possuem um método a ser implementado, em outras palavras, um método abstrato. 
Exemplos de interfaces já criadas pelo Java: 
· Runnable , Readable , Iterable , Comparable, consumer e outras.
RECAPTULANDO:
· Interface funcional contem só um método.
· Esse método é chamado de método abstrato.
· Lambda é ideal para interfaces funcionais.
· Lambda surgiu para tornar o código mais legível e para instanciar interfaces de modo mais simples, sem precisar criar cada uma separadamente. 
· Lambda facilita trabalhar com coleções (list, etc) e com streams.
Expressão tradicional x expressão com labdas:
Abaixo, uma comparação de uma expressão tradicional e uma com lambda, da interface comparator:
Comparator<Produto> comparator = new Comparator<Produto>() {
	@Override
	public int compare(Produto o1, Produto o2) {
		return o1.getPrice().compareTo(o2.getPrice());
	}
};
Usando Lambda Expression, podemos fazer isso com menos código:
Comparator<Produto> produtoComparator = (Produto c1, Produto c2) -> c1.getPrice().compareTo(c2.getPrice());
Outro exemplo:
Outro exemplo com lambda:
Estrutura do Lambda:
Uma expressão lambda em Java é composta por três partes principais:
1. Argumentos: Uma lista de argumentos separados por vírgulas, que especifica os parâmetros que a expressão lambda recebe. 
2. Setas: O operador "->" separa os argumentos da expressão lambda do corpo da função.
3. Corpo: contém a expressão que define a ação a ser realizada pela função. Esse corpo pode ser uma única expressão ou um bloco de código encapsulado em chaves "{}".
Um exemplo de expressão lambda simples em Java seria:
· (x, y) -> x + y
Com base no exemplo do código acima, nossa estrutura lambda é o seguinte:
Lambda é a representação resumida de uma função anônima. 
Uma função anônima quer dizer que:
· Não tem nome
· Não está associado a uma classe (função)
· Pode ser passada como argumento e diminui a quantidade de código que você precisa gerar.
O Lambda Expression é usado para a programação funcional em Interfaces Funcionais (que podem ser as que você criou, ou as próprias API do Java que são Interfaces Funcionais). 
E quando sabemos que uma Interface é Funcional? É uma interface que especifica exatamente um método abstrato.
STREAMS API
Para entender streams, é preciso entender Lambdas primeiro. 
Esse recurso permite reduzir o número de ‘for’.
Entenda mais na documentação oracle: 
https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html
Thread em java
Como rodar servidor no ecplise
Como construir java com mvc
Como conectar no banco de dados
O que é spring boot – criar aplicação do zero - https://medium.com/@mvalho/spring-boot-como-criar-uma-aplica%C3%A7%C3%A3o-do-zero-parte-1-2c3098c0e900
Como criar aplicação com spring mvc
Diferença MVC x Spring mvc
MATH
Permite trabalhar com métodos matemáticos.
LISTAS:
https://site.alura.com.br/conteudo/java-collections?utm_term=&utm_campaign=%5BSearch%5D+%5BPerformance%5D+-+Dynamic+Search+Ads+-+Artigos+e+Conte%C3%BAdos&utm_source=adwords&utm_medium=ppc&hsa_acc=7964138385&hsa_cam=11384329873&hsa_grp=111087461203&hsa_ad=645853715422&hsa_src=g&hsa_tgt=aud-456779235794:dsa-810524869174&hsa_kw=&hsa_mt=&hsa_net=adwords&hsa_ver=3&gclid=Cj0KCQjw0bunBhD9ARIsAAZl0E0a_3WRLrt12jf5xRJHA0mcaGWBzBDxvR8Y4r6lGFhHgpC9OXKitlQaAv33EALw_wcB
https://www.youtube.com/watch?v=kUHQY2O2RPU
https://www.youtube.com/watch?v=1NdM68V-KCM
Exercícios Fibonacci e operador ternário:
https://www.alura.com.br/apostila-java-orientacao-objetos/orientacao-a-objetos-basica
Exercícios POO:
https://www.alura.com.br/apostila-java-orientacao-objetos/resolucoes-exercicios
image6.png
image7.png
image8.emf
image9.png
image10.png
image11.png
image12.png
image13.png
image14.emf
image15.png
image16.png
image17.png
image18.emf
image19.png
image20.png
image21.png
image22.png
image23.png
image24.png
image25.png
image26.png
image27.png
image28.png
image29.png
image30.png
image31.png
image32.png
image33.png
image34.png
image35.png
image36.png
image37.png
image38.png
image39.png
image40.png
image41.png
image42.png
image43.png
image44.png
image45.png
image1.emf
image46.png
image47.png
image48.png
image49.png
image50.png
image51.png
image52.png
image53.png
image54.png
image2.png
image55.png
image56.png
image57.png
image3.png
image4.png
image5.emf