- Window / Perspective / Open Perspective / Other / Selecione Java
- Window / Show View / Console
- Window -> Perspective -> Reset Perspective
- Window -> Preferences -> General -> Appearance -> Theme: selecione Dark
- CTRL +
- CTRL -
- sysout Ctrl + Barra de espaço = System.out.println();
Após digitar algum comando ou variável basta pressionar
- Crtl + Barra de Espaço
que vai completar o comando ou variável
- CTRL + SHIFT + F
- CTRL + F11
Selecione o trecho do código que quer retornar e pressione
- SHIFT + Tab
- Ctrl + Shift + o
- File / New / Java Project
-
CTRL+SHIFT+B - marcar/desmarcar breakpoint
-
iniciar/continuar o debug
- F6 - executar um passo (pula função)
- F5 - executar um passo (entra na função)
- F7 - sair do método em execução
-
parar debug
-
Perspectiva Debug
-
Aba importante: Variables
Dentro da Classe clique:
- Botão direito -> Source -> Generate Constructor using Fields
- Botão direito -> Source -> Generate Getters and Setters
- Botão direito -> Source -> Generate toString
- Entry Point = Ponto de Entrada = public static void main(String[] args){}
- Padrão para long: sufixo "L"
- Padrão para float: sufixo "f"
- Padrão para char: aspas simples
- Padrão para string: aspas duplas
Quando criamos um array ou um objeto com os seguintes atributos, esses são os valores padrão inicialmente.
- byte = 0
- short = 0
- int = 0
- long = 0L
- float = 0.0f
- double = 0.0d
- char = '\u0000'
- String = null
- Object = null
- boolean = false
- não pode começar com dígito (use uma letra ou _)
- não usar acentos e til
- não pode deixar espaço em branco entre as letras ou palavras
- sugestão: use nomes que tem significados
- pacotes
- atributos
- métodos
- variáveis e parâmetros
- classes
- Nomes em Maiúsculo e se for composto deverá ser separado com _
- Constantes (PI) ou (NET_SALARY)
- Declaração: public static final double PI = 3.14159; => onde o final indica que é uma constante.
- String: Uma cadeia de caracteres Unicode IMUTÁVEL (segurança, simplicidade, thread safe)
- Object: Um objeto genérico (toda classe em Java é subclasse de object) exemplos: getClass, equals, hashCode, toString
%.2f = pega duas casas depois da virgula (, ou .)
%.4f = pega quatro casas depois da virgula (, ou .)
%s = pega a String declarada
%d = pega o inteiro declarado
%c = pega o char declarado
%n = quebra de linha no Java
\n = quebra de linha no C
char gender = 'F';
int age = 32;
double balance = 10.35784;
String name = "Maria";
System.out.printf("%.2f%n", balance);
System.out.printf("%.4f%n", balance);
System.out.printf("%s is %d years old, gender %c, and got balance = %.2f bitcoins%n", name, age,gender, balance);10,36
10,3578
Maria is 32 years old, gender F, and got balance = 10,36 bitcoins
import java.util.Locale;
Locale.setDefault(Locale.US);import java.util.Locale;
public static void main(String[] args){
double balance = 10.35784;
Locale.setDefault(Locale.US);
System.out.printf("%.4f%n", balance);
}10.36
s1 = sc.nextLine();Antes de fazer um nextLine()
- Se antes foi dada uma quebra de linha na stream de entrada sem o nextLine()
- Então é preciso fazer um nextLine() extra para "limpar" a quebra de linha que fica pendente na stream
int n1 = sc.nextInt();
sc.nextLine();- sqrt – raiz quadrada
A = Math.sqrt(x); //Variável A recebe a raiz quadrada de x- pow – potenciação
A = Math.pow(x, y); // Variável A recebe o resultado de x elevado a y- abs – valor absoluto
A = Math.abs(x); // Variável A recebe o valor absoluto de x! negação (Inverte a a condição)
&& E (Quando as duas condições são verdadeiras)
|| OU (Quando pelo menos uma condição é verdadeira)
- Precedência: ! (Negação) -> && (E)-> || (OU)
- Pode-se usar parêntesis à vontade Ex: 2 > 3 && 4 != 5 Resultado: true Ex: !(2>3) || 4 != 5 Resultado: true
-
Normalmente utilizados para programação de baixo nivel.
-
Geralmente é um micro controlador, programação com interface de rede e arduino.
& => Operação "E" bit a bit | => Operação "OU" bit a bit ^ => Operação "OU-exclusivo" bit a bit
a += b; // a = a + b;
a -= b; // a = a - b;
a *= b; // a = a * b;
a /= b; // a = a / b;
a %= b; // a = a % b;if-else (se-senão)
- Simples
- REGRA:
- V: executa o bloco de comandos
- F: pula o bloco de comandos
- REGRA:
if (condição){
comando
}- Composta
- REGRA:
- V: executa somente o bloco do if
- F: executa somente o bloco do else
- REGRA:
if (condição){
comando 1
}
else {
comando 2
}- Encadeamentos
if (condição){
comando 1
}
else if (condição){
comando 2
}
else {
comando 3
}- Formatar: toLowerCase(), toUpperCase(), trim()
- Recortar: substring(inicio), substring(inicio, fim)
- Substituir: Replace(char, char), Replace(string, string)
- Buscar: IndexOf, LastIndexOf
- str.Split(" ")
char caracter = sc.next().charAt(0);String s = "potato apple lemon";
String[] vect = s.split(" ");
String word1 = vect[0];
String word2 = vect[1];
String word3 = vect[2];- Estrutura opcional a vários if-else encadeados, quando a condição envolve o teste do valor de uma variável.
var minhaVariavel = (...);
switch (minhaVariavel) {
case 1:
System.out.println("Caso 1");
break;
case 2:
System.out.println("Caso 2");
break;
default:
System.out.println("Caso padrão");
}-
Estrutura opcional ao if-else quando se deseja decidir um VALOR com base em uma condição.
-
Sintaxe: ( condição ) ? valor_se_verdadeiro : valor_se_falso Exemplos: ( 2 > 4 ) ? 50 : 80 ( 10 != 3 ) ? "Maria" : "Alex" 80 "Maria"
- Escopo de uma variável: é a região do programa onde a variável é válida, ou seja, onde ela pode ser referenciada.
- Uma variável não pode ser usada se não for iniciada.
-
Representam um processamento que possui um significado Math.sqrt(double) System.out.println(string)
-
Principais vantagens: modularização, delegação e reaproveitamento
-
Dados de entrada e saída Funções podem receber dados de entrada (parâmetros ou argumentos) Funções podem ou não retornar uma saída
-
Em orientação a objetos, funções em classes recebem o nome de "métodos"
-
public static void nome_da_funcao (parametro)
-
public => fica disponivel para outras classes.
-
static => pode ser chamada independente de ter sido criado um objeto.
-
void => executa uma ação e não retorna um valor (void = vazio).
public static void showResult(int value){
System.out.println("Higher = " + value)
}-
É uma estrutura de controle que repete um bloco de comandos enquanto uma condição for verdadeira.
-
Quando usar: quando não se sabe previamente a quantidade de repetições que será realizada.
-
Estrutura "enquanto"
- Regra:
- V: executa e volta
- F: pula fora
- Regra:
while ( condição ) {
comando 1
comando 2
}É uma estrutura de controle que repete um bloco de comandos para um certo intervalo de valores. Quando usar: quando se sabe previamente a quantidade de repetições, ou o intervalo de valores.
for ( início ; condição ; incremento) {
comando 1
comando 2
}-
Menos utilizada, mas em alguns casos se encaixa melhor ao problema.
-
O bloco de comandos executa pelo menos uma vez, pois a condição é verificada no final.
-
Regra:
- V: volta
- F: pula fora
-
Sintaxe / regra
do {
comando 1
comando 2
} while ( condição );
-
Um vetor corresponde a uma coleção de dados de tamanho fixo, indexada, unidimensional e homogênea
-
Indexada: os elementos são acessados por meio de índices
-
Unidimensional: uma dimensão
-
Homogênea: todos dados são do mesmo tipo
-
Em Java a primeira posição e um vetor é a posição 0
-
Um arranjo deve ser alocado previamente, antes de ser utilizado.
-
Uma vez alocado, sua quantidade de elementos é fixa.
-
Declaração: double[] B;
-
Instanciação: B = new double[5];
-
Acesso: B[3] = 20;
double[] b = new double[5];
Regra de 3 (como montar)
int n = sc.nextInt();
int[] idades = new int[n];
for (int i = 0; i < n; i++) {
idades[i] = sc.nextInt();
}
int cont = 0;
for (int i = 0; i < n; i++) {
if (idades[i] < 16) {
cont = cont + 1;
}
}
double x = (double) cont * 100 / n;int N = sc.nextInt();
String[] nomes = new String[N];
for (int i=0; i<N; i++) {
nomes[i] = sc.next();
}
System.out.println("Nomes lidos:");
for (String s : nomes) {
System.out.println(s);
}- length = quantidade de elementos.
int n = sc.nextInt();
Vetores[] vect = new Vetores[n];
for(int i=0; i<vect.length; i++) {
sc.nextLine();
String name = sc.nextLine();
double price = sc.nextDouble();
vect[i] = new Vetores(name, price);
}-
Em programação, "matriz" é o nome dado a arranjos bidimensionais
- Atenção: "vetor de vetores"
-
Arranjo (array) é uma estrutura de dados:
- Homogênea (dados do mesmo tipo)
- Ordenada (elementos acessados por meio de posições)
- Alocada de uma vez só, em um bloco contíguo de memória
-
Vantagens:
- Acesso imediato aos elementos pela sua posição
-
Desvantagens:
- Tamanho fixo
- Dificuldade para se realizar inserções e deleções
- Indexada: os elementos são acessados por meio de índices
- bidimensional: duas dimensões
- Homogênea: todos dados são do mesmo tipo
- Em Java a primeira posição de uma matriz é a posição 0, 0 (linha 0, coluna 0)
- Um arranjo deve ser alocado previamente, antes de ser utilizado. Uma vez alocado, sua quantidade de elementos é fixa
declaração => double[][] A;
instanciação => A = new double[3][4];double[][] A = new double[3][4];A[1][2] = 10;-
É um tipo estruturado que pode conter (membros):
- Atributos (dados / campos)
- Métodos (funções / operações)
-
A classe também pode prover muitos outros recursos, tais como:
- Construtores
- Sobrecarga
- Encapsulamento
- Herança
- Polimorfismo
-
Exemplos:
- Entidades: Produto, Cliente, Triangulo
- Serviços: ProdutoService, ClienteService, EmailService, StorageService
- Controladores: ProdutoController, ClienteController
- Utilitários: Calculadora, Compactador
- Outros (views, repositórios, gerenciadores, etc.)
- Classe: é a definição do tipo
- Objetos: são instâncias da classe
package course; // Pacote da Classe
public class Triangle { //Nome da Classe
public double a; // Atributos da Classe
public double b; // Atributos da Classe
public double c; // Atributos da Classe
// Metodo
public // O prefixo "public" indica que o atributo ou método pode ser usado em outros arquivos
double // Tipo do dado que o método retorna (se o método não retorna nada, usa-se a palavra "void")
area // Nome do método
() // Lista de parâmetros do método
public double area() {
double p = (a + b + c) / 2.0;
return Math.sqrt(p * (p - a) * (p - b) * (p - c));
}Observação: Quando os membros da classe não são estáticos, você é obrigado a instancia-los para poder utiliza-la.
Quais são os benefícios de se calcular a área de um triângulo por meio de um MÉTODO dentro da CLASSE Triangle?
- Reaproveitamento de código: nós eliminamos o código repetido (cálculo das áreas dos triângulos x e y) no programa principal.
- Delegação de responsabilidades: quem deve ser responsável por saber como calcular a área de um triângulo é o próprio triângulo.
- A lógica do cálculo da área não deve estar em outro lugar.
-
Também chamados membros de classe
- Em oposição a membros e instância
-
São membros que fazem sentido independentemente de objetos.
- Não precisam de objeto para serem chamados.
- São chamados a partir do próprio nome da classe.
-
Aplicações comuns:
- Classes utilitárias => Math.sqrt(double)
- Declaração de constantes
-
Uma classe que possui somente membros estáticos, pode ser uma classe estática também.
- Esta classe não poderá ser instanciada.
-
Constante
- Declaração:
public static final double PI = 3.14159; // onde o final indica que é uma constante.-
Construtor
- É uma operação especial da classe, que executa no momento da instanciação do objeto
-
Usos comuns:
- Iniciar valores dos atributos
- Permitir ou obrigar que o objeto receba dados / dependências no momento de sua instanciação (injeção de dependência)
-
Se um construtor customizado não for especificado, a classe disponibiliza o construtor padrão:
Product p = new Product();- É possível especificar mais de um construtor na mesma classe (sobrecarga)
public String name;
public double price;
public int quantity;
public Product(String name, double price, int quantity) {
this.name = name;
this.price = price;
this.quantity = quantity;
}public Product(String name, double price, int quantity) {
this.name = name;
this.price = price;
this.quantity = quantity;
}- É uma referência para o próprio objeto
- Usos comuns:
- Diferenciar atributos de variáveis locais
- Passar o próprio objeto como argumento na chamada de um método ou construtor
- É um recurso que uma classe possui de oferecer mais de uma operação com o mesmo nome, porém com diferentes listas de parâmetros.
- É um princípio que consiste em esconder detalhes de implementação de uma classe, expondo apenas operações seguras e que mantenham os objetos em um estado consistente.
- Regra de ouro: o objeto deve sempre estar em um estado consistente, e a própria classe deve garantir isso.
- Um objeto NÃO deve expor nenhum atributo (modificador de acesso private)
- Os atributos devem ser acessados por meio de métodos get e set
- Padrão JavaBeans: https://en.wikipedia.org/wiki/JavaBeans
Padrão para implementação de getters e setters
private String name;
private double price;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}- https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html
- private: o membro só pode ser acessado na própria classe
- (nada): o membro só pode ser acessado nas classes do mesmo pacote
- protected: o membro só pode ser acessado no mesmo pacote, bem como em subclasses de pacotes diferentes
- public: o membro é acessado por todas classes (ao menos que ele resida em um módulo diferente que não exporte o pacote onde ele está)
- Classes são tipos referência
- Variáveis cujo tipo são classes não devem ser entendidas como caixas, mas sim “tentáculos” (ponteiros) para caixas
- Em Java, tipos primitivos são tipos valor. Tipos valor são CAIXAS e não ponteiros.
- É um processo que automatiza o gerenciamento de memória de um programa em execução
- O garbage collector monitora os objetos alocados dinamicamente pelo programa (no heap), desalocando aqueles que não estão mais sendo utilizados.
-
Objetos alocados dinamicamente, quando não possuem mais referência para eles, serão desalocados pelo garbage collector.
-
Variáveis locais são desalocadas imediatamente assim que seu escopo local sai de execução
-
Sintaxe opcional e simplificada para percorrer coleções
-
Sintaxe:
for (Tipo apelido : coleção) {
<comando 1>
<comando 2>
}- Leitura: "para cada objeto 'obj' contido em vect, faça:"
String[] vect = new String[] {"Maria", "Bob", "Alex"};
for (int i=0; i< vect.length; i++) {
System.out.println(vect[i]);
}
for (String obj : vect) {
System.out.println(obj);
}-
Conceito de lista
-
Tipo List - Declaração, instanciação
-
Demo
-
Referência: https://docs.oracle.com/javase/10/docs/api/java/util/List.html
-
Assuntos pendentes:
- interfaces
- generics
- predicados (lambda)
-
Lista é uma estrutura de dados:
- Homogênea (dados do mesmo tipo)
- Ordenada (elementos acessados por meio de posições)
- Inicia vazia, e seus elementos são alocados sob demanda
- Cada elemento ocupa um "nó" (ou nodo) da lista
-
Tipo (interface): List
-
Classes que implementam: ArrayList, LinkedList, etc.
-
Vantagens:
- Tamanho variável
- Facilidade para se realizar inserções e deleções
-
Desvantagens:
- Acesso sequencial aos elementos *
-
Tamanho da lista: size()
-
Obter o elemento de uma posição: get(position)
-
Inserir elemento na lista: add(obj), add(int, obj)
-
Remover elementos da lista: remove(obj), remove(int), removeIf(Predicate)
-
Encontrar posição de elemento: indexOf(obj), lastIndexOf(obj)
-
Filtrar lista com base em predicado:
List<Integer> result = list.stream().filter(x -> x > 4).collect(Collectors.toList());- Encontrar primeira ocorrência com base em predicado:
Integer result = list.stream().filter(x -> x > 4).findFirst().orElse(null);- Assuntos pendentes:
- interfaces
- generics
- predicados (lambda)
- Representa um INSTANTE
-
https://docs.oracle.com/javase/10/docs/api/java/util/Date.html
-
Um objeto Date internamente armazena:
- O número de milissegundos desde a meia noite do dia 1 de janeiro de 1970 GMT (UTC)
- GMT: Greenwich Mean Time (time zone)
- UTC: Coordinated Universal Time (time standard)
-
https://docs.oracle.com/javase/10/docs/api/java/text/SimpleDateFormat.html
-
Define formatos para conversão entre Date e String
- dd/MM/yyyy -> 23/07/2018
- dd/MM/yyyy HH:mm:ss -> 23/07/2018 15:42:07
- Formato: yyyy-MM-ddTHH:mm:ssZ
- Exemplo: "2018-06-25T15:42:07Z"
- Date y3 = Date.from(Instant.parse("2018-06-25T15:42:07Z"));
SimpleDateFormat sdf1 = new SimpleDateFormat("dd/MM/yyyy");
SimpleDateFormat sdf2 = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
SimpleDateFormat sdf3 = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
sdf3.setTimeZone(TimeZone.getTimeZone("GMT"));
Date x1 = new Date();
Date x2 = new Date(System.currentTimeMillis());
Date x3 = new Date(0L);
Date x4 = new Date(1000L * 60L * 60L * 5L);
Date y1 = sdf1.parse("25/06/2018");
Date y2 = sdf2.parse("25/06/2018 15:42:07");
Date y3 = Date.from(Instant.parse("2018-06-25T15:42:07Z"));
System.out.println("x1: " + x1);
System.out.println("x2: " + x2);
System.out.println("x3: " + x3);
System.out.println("x4: " + x4);
System.out.println("y1: " + y1);
System.out.println("y2: " + y2);
System.out.println("y3: " + y3);
System.out.println("-------------");
System.out.println("x1: " + sdf2.format(x1));
System.out.println("x2: " + sdf2.format(x2));
System.out.println("x3: " + sdf2.format(x3));
System.out.println("x4: " + sdf2.format(x4));
System.out.println("y1: " + sdf2.format(y1));
System.out.println("y2: " + sdf2.format(y2));
System.out.println("y3: " + sdf2.format(y3));
System.out.println("-------------");
System.out.println("x1: " + sdf3.format(x1));
System.out.println("x2: " + sdf3.format(x2));
System.out.println("x3: " + sdf3.format(x3));
System.out.println("x4: " + sdf3.format(x4));
System.out.println("y1: " + sdf3.format(y1));
System.out.println("y2: " + sdf3.format(y2));
System.out.println("y3: " + sdf3.format(y3));SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
Date d = Date.from(Instant.parse("2018-06-25T15:42:07Z"));
System.out.println(sdf.format(d));
Calendar cal = Calendar.getInstance();
cal.setTime(d);
cal.add(Calendar.HOUR_OF_DAY, 4);
d = cal.getTime();
System.out.println(sdf.format(d));SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
Date d = Date.from(Instant.parse("2018-06-25T15:42:07Z"));
System.out.println(sdf.format(d));
Calendar cal = Calendar.getInstance();
cal.setTime(d);
int minutes = cal.get(Calendar.MINUTE);
int month = 1 + cal.get(Calendar.MONTH);
System.out.println("Minutes: " + minutes);
System.out.println("Month: " + month);- É um tipo especial que serve para especificar de forma literal um conjunto de constantes relacionadas
- Palavra chave em Java: enum
- Vantagem: melhor semântica, código mais legível e auxiliado pelo compilador
- Referência: https://docs.oracle.com/javase/tutorial/java/javaOO/enum.html
package entities.enums;
public enum OrderStatus {
PENDING_PAYMENT,
PROCESSING,
SHIPPED,
DELIVERED;
}
package entities;
import java.util.Date;
import entities.enums.OrderStatus;
public class Order {
private Integer id;
private Date moment;
private OrderStatus status;
(...)
}OrderStatus os1 = OrderStatus.DELIVERED;
OrderStatus os2 = OrderStatus.valueOf("DELIVERED");
-
Em um sistema orientado a objetos, de modo geral "tudo" é objeto.
-
Por questões de design tais como organização, flexibilidade, reuso, delegação, etc., há várias categorias de classes:
- Views
- Controllers
- Entities
- Services
- Repositories
- É um tipo de associação que permite que um objeto contenha outro
- Relação "tem-um" ou "tem-vários"
- Vantagens
- Organização: divisão de responsabilidades
- Coesão
- Flexibilidade
- Reuso
- Nota: embora o símbolo UML para composição (todo-parte) seja o diamante preto, neste contexto estamos chamando de composição qualquer associação tipo "tem-um" e "tem-vários".
- Na classe do objeto quando houver lista, na hora de gerar o construtor não devemos marcar a lista mas sim instanciar a lista separada.
package entities;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import entities.enums.WorkerLevel;
public class Worker {
private String name;
private WorkerLevel level;
private Double baseSalary;
//Composição de Objetos (Associação)
private Department department; // Associação de 1
private List<HourContract> contracts = new ArrayList<>(); //Associação de vários | devemos criar uma lista | instanciar em vez de colocar no construtor.
public Worker() {
}
public Worker(String name, WorkerLevel level, Double baseSalary, Department department) {
this.name = name;
this.level = level;
this.baseSalary = baseSalary;
this.department = department;
}public String toString() {
StringBuilder sb = new StringBuilder();
sb.append(title + "\n");
sb.append(likes);
sb.append(" Likes - ");
sb.append(sdf.format(moment) + "\n");
sb.append(content + "\n");
sb.append("Comments:\n");
for (Comment c : comments) {
sb.append(c.getText() + "\n");
}
return sb.toString();
}- É um tipo de associação que permite que uma classe herde todos dados e comportamentos de outra
- Definições importantes
- Vantagens
- Reuso
- Polimorfismo
- Sintaxe
- class A extends B
