Prévia do material em texto

na prática
método main
Variáveis em java
Funções em java
Ler entrada em java (Scanner)
Execução e compilação
Condicionais
Operadores lógicos, igualdade e relacionais e (equals)
Laços
Conversão, caixa alta
Arrays
Problema tamanho do array
Máximo e Mínimo
Atributo, construtor e this
get e set (acessar e alterar)
Null
Exceções
Deputação (debug)
pular linha
verificar se é vazio
Testes e Junit
Métodos que todo objeto tem
chamar objeto em outra classe (cast)
Asserts e testes
Coleções, ArrayList, Conjunto, size (tamanho), add
Métodos de ArrayList, acessar, deletar, adicionar
manipular listas ( For-each, interador, indice)
Conjuntos
Conjuntos: manipulação
Mapas: chave e valor (métodos)
Manipular mapas
interfaces
Tirar pontuação de strings
gerar javadoc
extends e aproveitamento de codigo
main
public class Exemplo{
public static void main(Strings args[]){
System.out.println(“diz mesmo...”);
}
}
Visibilidade
Sistema saída
Primeiro método a ser executado
Não retorna nadaNome da classe
opera sem contexto
Definições
→ Método opera com contexto, funções não.
→ Valor: representação de algo real
→ tipo: natureza do valor. ex. inteiro, string...
Variáveis em java
int contagem = 2;
String texto = “Txun”
int ano = 1973;
boolean ehverdade = True;
char primeirochar = ‘a’
int idade = 2020-ano
double fator = 0.6;
Tipo em azul
Precisamos especificar o tipo da 
variável pois é uma tipagem estática, 
“engessada”. Diferente da tipagem 
dinâmica quando descobrimos o tipo 
quando o cod. é executado.
Dica: Geralmente nome de variável sem “-”, mas é comum encontrar em constantes maiúsculas. 
A cada classe Wrraper 
temos a representação 
de um tipo. ex. o tipo int 
tem a classe Integer.
Funções em java
Exemplos:
public static int dobro(int valor){
return valor*2;
}
public static double sum(int a, int b){
return 0,5+dobro(a)+dobro(b);
}
public static boolean ehPar(int a){
return valor%2==0;
}
visibilidade static tipo nome(parâmetros){
return “algo” 
}
Ler entrada em java (Scanner)
import java.util.Scanner;
Scanner sc = new Scanner(System.in);
System.out.println(sc.nextline( ));
System.out.println(sc.nextInt( ));
int a = sc.nextInt( );
importar scanner
Criando o scanner 
Nome variável entrada do sistema
Ler a linha da entrada
Pegar o inteiro da entrada
Criar uma variável para receber o valor
Execução e compilação
JVM → máquina virtual do java, traduz o comando para bytecode para a máquina.
javac mensagem.java
java mensagem
compila
executa
Condicionais
if (condição){
…
}else if (condição){
...
}else{
...
}
Exemplo:
int num = 2;
if (num%2==0){
System…(“par”)
}else if (num%2!=0){
System…(“impar”)
}else{
System…(“não tá danado chegar aqui”)
}
Operadores lógicos, igualdade e relacionais e (equals)
lógicos: && (para quando queremos mais de uma opção verdadeira), II (quando queremos uma das 
opções verdadeiras) e ! (quando queremos negar uma informação. tipo o not do python)
igualdade: == e !=
relacionais: >=, 
obs.: Em java strings são objetos, então devemos ter cuidado quando formos comparar as variáveis. 
Dessa forma, ao invés de fazer. ex:
String a = “tudo bem”
String b = “tudo bem”
a==b
Fazemos: a.equals(b) 
Utilizamos o método equals.
Laços
for (int i = 0; i=valores.length){
valores = copiaAumentada(valores);
}
Aumenta +100 espaços.
podemos mudar isso...
Máximo e Mínimo
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
Atributo, construtor e this
criar atributos, caracteristicas do meu objeto:
public int x; //atributo 
construtor para criar objetos:
Ponto p1 = new Ponto(); //cria o objeto
p1.x = 10; //atribuindo valor ao objeto 
this é uma referencia para o objeto que foi criado
get e set
public int getX( ) {
return this.x; //faz com que outras classes acessem o valor x
}
public void set(int x){
this.x = x; // altera o valor de x
}
você faz o controle através desses métodos acessores.
Null
Quando um objeto não aponta para nada ele é null.
ex. um array que não tem nada em determinada posição, vai ter algo nulo.
erro“NullPoint...” erro quando você manda executar um objeto que não aponta 
para nada.
Exceções
if (cpf == null){
throw new NullPointerException(“CPF NULO”)
}
if (“”.equals(cpf.trim())){
throw new lllegalArgumentException(“CPF VAZIO”);
}
se ‘proteger’ do usuário. Colocar uma nova entrada por exemplo...
Deputação (debug)
breakpoint: onde eu quero q o programa pare
com o debug vc analisa cada linha do seu codigo
→ colocar o break point, vai na linha, botão direito e pá.
→ botão diteiro, debug as, java aplicattion
F5 durante o debug mostra cada passo q o codigo ta percorrendo
F6 pula
F7 sai do método atual e volta
F8 pula até o breakpoint que a gente definiu, caso não tenha vai para o final.
pular linha
System.LineSeparator( )
saida += original+ System.lineSeparator();
Verificar se é vazio
isBlank
Métodos que todo objeto tem
toString( )
hashCode( )
public int hashCode() {
return this.matricula.hashCode();
}
equals( )
Testes e Junit
botão direito → build path → add libraries → Junit
Criar source folder → class → import Junit
Asserts 
Caso use ponto flutuante precisa ter cuidado para ter precisão. 
chamar objeto em outra classe (cast)
ex.
Contato contato = (Contato) contato[i];
Para criar, ex.:
Contato contato = new contato();
Asserts e testes
assertEquals
assertTrue
assertFalse
@BeforeEach
void Inicia( ){
Terreno t1 = new Terreno(“vanderson”, 123);
}
@Test 
void TestObjeto( ){
Terreno t1 = new Terreno(“vanderson”, 123);
Terreno t2 = new Terreno(“vanderson”, 123);
assertEquals(t1,t2)
}
@Test
void TestTerrenoVazio( ) {
try{
new Terreno(“ ”, 5261);
fail(“era esperado ums exceção”);
}catch (IIIlegalArgumentException iae){
}
}
Coleções, ArrayList, Conjunto, size (tamanho), add
ArrayList alunos = new ArrayList();
alunos.add(new Aluno(“menino ...”,1));
ArrayList lista = new ArrayList();
lista.add(new Integer(1)); 
lista.size(); → tamanho
ArrayList alunos = new ArrayList( );
alunos.add (new Aluno(“menino ...”,1));
HashSet conjunto = new HashSet();
lista.add(new Integer( ));
← Generics, só aceita objetos do tipo aluno
List lista = new ArrayList();
Colocar mais generico a coleção
← lista de inteiros
←lista normal
← conjunto
Collections. 
Essa classe tem 
diversas operações 
que podemos usar 
em uma lista.
Métodos de ArrayList, acessar, deletar, adicionar
adiciona: listaElementos.add(elemento)
remove: listaElementos.remove(elemento);
acessa: listaElementos.get(posicao);
Se um elemento pertence a lista: listaElementos.contains(elemento);
O index de um elemento: (Integer) listaElementos.indexOf(elemento);
tamanho: listaElementos.size();
manipular listas ( For-each, interador, indice)
// Alternativa 1: For-each
private ArrayList elementos 
= new ArrayList();
public int somarElementos() 
{
 int soma = 0;
 for (Object o : 
elementos) {Integer i = 
(Integer) o;
 soma += i;
 }
 return soma;
}
// Alternativa 2: Utilizando 
um objeto Iterator
private ArrayList elementos = 
new ArrayList();
public int somarElementos() {
 int soma = 0;
 Iterator itr = 
elementos.iterator();
 while (itr.hasNext()) {
 Integer i = (Integer) 
itr.next();
 soma += i;
 }
 return soma
}
// Alternativa 3: Utilizando o 
índice
private ArrayList elementos = new 
ArrayList();
public int somarElementos() {
 int soma = 0;
 for (int i = 0; i palavras = new HashSet(); ou Set
public boolean adicionarElemento(String elemento) {
 return palavras.add(elemento);
}
public boolean pertence(String elemento) {
 return palavras.contains(elemento);
}
public boolean remove(String elemento) {
 return palavras.remove(elemento);
}
public int tamanho() {
 return palavras.size();
}
Conjuntos: manipulação
conjuntos ignoram a ordem e a repetição.
// Alternativa 1: For-each
private HashSet palavras = new HashSet();
public int contarPalavrasComecandoEmVogais() {
 int conta = 0;
 for (String palavra : palavras) {
 if (palavra.startswith(“a”) || 
palavra.startswith(“e”) || palavra.startswith(“i”) || 
palavra.startswith(“o”) || palavra.startswith(“u”)) {
 conta += 1;
 }
 }
 return conta;
}
// Alternativa 2: Utilizando um objeto Iterable
private HashSet palavras = new HashSet();
public int contarPalavrasComecandoEmVogais() {
 int conta = 0;
 Iterator itr = palavras.iterator();
 while (itr.hasNext()) {
 String palavra = itr.next();
 if (palavra.startswith(“a”) || palavra.startswith(“e”) || 
palavra.startswith(“i”) || palavra.startswith(“o”) || 
palavra.startswith(“u”)) {
 conta += 1;
 }
 }
 return conta;
}
Mapas: chave e valor (métodos)
private HashMap mapaMatriculaAlunos = new HashMap(); Ou Map só no inicio
public Aluno adicionaAluno(String matricula, Aluno aluno) {
 return this.mapaMatriculaAlunos.put(matricula, aluno);
 // retorna o aluno anteriormente associado a essa matricula, ou nulo se não existia tal aluno
}
public boolean existeAluno(String matricula) {
 return this.mapaMatriculaAlunos.containsKey(matricula);
}
public boolean existeAluno(Aluno aluno) {
 return this.mapaMatriculaAlunos.containsValue(aluno);
}
public Aluno recuperaAluno(String matricula) {
 return this.mapaMatriculaAlunos.get(matricula);
}
public Aluno remove(String matricula) {
 return this.mapaMatriculaAlunos.remove(matricula);
}
public int numeroDeAlunos() {
 return this.mapaMatriculaAlunos.size();
}
Manipular mapas
// Alternativa 1: Pelas chaves
private HashMap mapaMatriculaAlunos = new HashMap();
public void alterarTurma(String turma) {
 for (String matricula : this.mapaMatriculaAlunos.keySet()) {
 Aluno aluno = this.mapaMatriculaAlunos.get(matricula);
 aluno.setTurma(turma);
 }
}
// Alternativa 2: Pelos valores
private HashMap mapaMatriculaAlunos = new HashMap();
public void alterarTurma(String turma) {
 for (Aluno aluno : this.mapaMatriculaAlunos.values()) {
 aluno.setTurma(turma);
 }
}
// Alternativa 3: Pelas chaves e valores
private HashMap mapaMatriculaAlunos = new HashMap();
public void alterarTurma(String turma) {
 for (Entry entry : this.mapaMatriculaAlunos.entrySet()) {
 Aluno aluno = entry.getValue();
 aluno.setTurma(turma);
 }
}
Interfaces
public class Circulo implements Figura{
@Override
public double area(double raio) { return Math.PI * Math.pow(raio, 2); }
@Override
public double perimetro() { return 2 * Math.PI * raio; }
}
public interface Figura {
public double area();
public double perimetro();
}
continua
public interface MinhaPrimeiraInterface {
public void metodo1();
public int metodo2();
public String metodo3(String 
parametro1);
}
public class MinhaClasse implements 
MinhaPrimeiraInterface {
@Override
public void metodo1() {
}
@Override
public int metodo2() {
return 0;
}
@Override
public String metodo3(String parametro1) {
// TODO Auto-generated method stub
return null;
public static void main(String[] args) {
}
}
if (funcionarioDAO instanceof BasicoDAO) 
funcionarioDAO.salvar(Funciona
rio001); else 
System.err.println( "A Classe 
FuncionarioDAO não implementa BasicoDAO, 
nenhum procedimento foi realizado" ); 
}
Analisa se uma classe 
está sendo instanciada
Tirar pontuação de strings
texto.replaceAll("\\p{Punct}", "");
gerar javadoc
project e generate javadoc
interfaceLogger 
imprimeLogger() 
Array 1
extends e aproveitamento de codigo
public class Nome extends ClasseComMetodosGerais
public Nome(){ 
super(para atualizar metodos da classe superior)
}
public class ClasseComMetodoGerais implements interface{
}
A ClasseComMetodoGerais pode ser abstrada, caso não seja necessario instancia-la
optional
https://medium.com/@racc.costa/optional-no-java-8-e-no-java-9-7c52c4b797f1