Java

Array Classe Abstrata Comando de Iteração

Comando de Seleção Conceitos Básicos
Selecionar Herança & Poliformismo Interface
Tratamento de Exeções

💡 Java é uma linguagem compilada → JVM (código em java é

transformado em bytecode, sendo assim, qualquer sistema com a
JVM instalada pode rodar esse código)

Criando uma variável

public class Pessoa{
public static void main(String[]args){
//criando uma variável
String nome = Rafaela;
//mostrando na tela
[Link]("Olá " + nome);

para acessar a variável salva basta usar seu nome → ex.: print(X)

Java 1
 ‐ variável local pertence ao método
‐ variável global pertence à classe
‐ variáveis chuck Norris são as que não morrem
‐ escopo de uma variável é onde ela é visível

Criando um objeto
public class Pessoa{
private String nome;
private int idade;

public String toString(){

return "Pessoa nome = " + nome + ", idade = " + idad
e;
}

public Pessoa(String nome, int idade){

[Link] = nome;
[Link] = idade;
}

public String getNome(){

return [Link];
}

public int getIdade(){

return [Link];
}

public void setNome(String nome){

[Link] = nome;
}

public void setIdade(int idade){

[Link] = idade;
}

Java 2
 }

public class NovaPessoa {

public static void main(String[]args){
Pessoa pessoa1 = new Pessoa("Rafaela", 19);
[Link](pessoa1);
}
}

retorno:
Pessoa nome = Rafaela, idade = 19

‐ a classe main é uma classe de entrada, então não é uma boa prática escrever
atributos dentro dessa classe
‐ se algo é criado dentro de um colchetes, ele só vai existir lá dentro por isso o
método de impressão precisou ser escrito junto com a criação do objeto, se
não ele não conseguiria exibir o objeto (variável local → criada dentro do
método)
‐ this. serve para deixar a variável permanente na memória (variável chuck
norris → variáveis que não morrem)
‐ variáveis global pertencem a classe

Entrada de Dados
import [Link];

public class EntradaDeDados {

public static void main(String[] args) {
Scanner scanner = new Scanner([Link]);

[Link]("Digite seu nome: ");

String nome = [Link]();

Java 3
 [Link]("Digite sua idade: ");
int idade = [Link]();

[Link]("Olá, " + nome + "! Você tem " + idad

e + " anos.");
}
}

Regra de Negócio
//classe com atributos
public class Pessoa{
private String nome;
private int idade;
private String cpf;

//método contrutor que recebe todos os atributos

//+ criando uma regra de negócio para idade
public Pessoa(String nome, int idade, String cpf){
[Link] = nome;
if(idade < 0){
[Link] = 0;
} else {
[Link] = idade;
}
[Link] = cpf;
//se eu criar um método set preciso escrever a mesma coisa

Herança e Poliformismo
‐ herança serve para reaproveitamento de código

‐ para duas classes interagirem elas precisam se conhecer → objeto de uma

classe interage com o objeto de outra classe
‐ a herança existe quando uma classe mais especializada é criada a partir de
uma classe já existente → subclasse herda os atributos e métodos da

Java 4
 superclasse (atributos e métodos de uma subclasse são exclusivos a ela)
subclasses também podem ter subclasses
‐ tipos de métodos quando se tem uma herança

sobre escrito → foi escrito na classe mãe e na classe filha

herdado → foi escrito só na classe mãe
exclusivo → foi escrito só na classe filha
sobre carga → mesmo construtor com parâmetros diferentes
‐ a primeira linha do construtor da subclasse é a chamada do construtor da
superclasse → quando eu crio uma subclasse a primeira coisa que preciso
fazer é armazenar na memória as informações da superclasse

public class Gerente extends Funcionario

//classe Gerente é um tipo de Funcionário

Criando um objeto Gerente

public Gerente (String n, double s, int d) {

super(n, s, d);
nomeSecretário = "Alfredo";
}

→ código sempre chama o que é mais perto

‐ o construtor com a classe menos específica é chamada de classe abstrata

‐ poliformismo é quando um objeto assume a diferentes formas → faço uma

referência apontar para diferentes objetos

Atleta a = new Corredor();

//ao decorrer do código preciso mudar essa referência,
//e eu posso
a = new Nadador();

para que a referência consiga acessar os métodos exclusivos de cada

subclasse eu preciso criar uma relação

Java 5
 Corredor c = (Corredor)a;
[Link]();
//não posso escrever [Link] porque atleta não corre, mas c
orredor sim c não é um corredor novo, e sim um que já exist
e (a)

Exemplo visual

tem a sobre carga do método emitir som

na classe teste Animal podemos ver o poliformismo → emir som vai latir e
miar
‐ up casting → eu faço uma referência da superclasse aponta para um objeto
da subclasse
‐ down casting → a minha referência da superclasse está explicitamente
dizendo que ela se comporta como tal subclasse
‐ instanceof: vê se uma referência foi instanciada para determinada classe

Atleta a = new ___

Java 6
 [Link]();
[Link]();

if(a instanceof Corredor){

Corredor c = (Corredor)a;
[Link]();
//ou ((Corredor)a).corre();

//esse if só vai rodar se o a lá em cima estiver apontando

//para um new Corredor

‐ para a superclasse acessar um método exclusivo ela precisa se comportar

como a subclasse

Inter i = new Gremio();

[Link];
((Gremio)i).ganha();

‐ uma subclasse não pode subir e ser uma superclasse

Funcionario f = new Estagiario();

Estagiario e = new Estagiario();
// o e nunca vai subir na vida, ele sempre vai ser um
//estagiário, já o f é um funcionário que no momento
//está se comportando como estagiário, futuramente
//esse f pode apontar para gerente por exemplo

Classe Abstrata

💡 classes que eu não consigo gerar objetos a partir dela, não

consigo instanciar → servem como molde para criação de classes
concretas (subclasses)

muitas das vezes as superclasses irão ser abstratas

Java 7
 💡 ex: tenho a superclasse deputado com duas subclasses, deputado
federal e deputado estadual. quando eu for criar objetos, com as
informações de cada deputado, eles já estarão dentro da
subclasse, não irei criar um deputado aleatório, irei criar um
deputado ou estadual ou federal. por isso as superclasses não
precisam ser instanciadas

💡 lembrando que para criar uma subclasse eu não preciso

instanciar, eu só estendo da superclasse

método abstrato não tem código dentro dele (sem {}) → Todos os métodos
abstratos herdados da superclasse precisam ser preenchidos para que o
código rode
Se uma classe tem um método abstrato, ela é obrigatoriamente abstrata
também. Porem nem toda classe abstrata precisa de um método abstrato
Criando um método e uma classe abstrata
Método abstrato

public abstract void teste();

Classe abstrata

public abstract class Pessoa

Não posso criar objetos de uma classe abstrata mas posso criar referências
dessa classe
só consigo ter arrays de subclasses
instance of → imprime informações específicas

Interfaces
servem para comunicação entre partes distintas
Regras de interface

Java 8
 Todos os métodos precisar ser abstratos e públicos
Não pode conter implementação
Todos os atributos precisam ser constantes
interfaces também servem como modelos (não são classes → não podem
ser instanciadas)
uma classe pode implementar várias interfaces

Criando interface

public interface MinhaInterface{

Classes implementa uma interface ou mais de uma

public class X implements Interface {

public class Y implements Interce1, Interface2{

@Override serve para quando sobrescrevo um método

Herdando uma classe e implementando ao mesmo tempo

public class X extends Y implements Interface {

posso tem um array de interface → dentro desse array tenho várias objetos
que implementaram essa interface

Java 9
 Diferença entre Classe Abstrata e Interface
Classes abstratas são feitas para reutilização de código, não são instanciadas
mas posso criar subclasses a partir dela. Já as interfaces servem para
contratos, um modelo que precisa ser seguido, elas não podem ser
instanciadas e nem ter atributos e métodos que não sejam abstratos.

Comando de Seleção (if/else e switch/case)

if

if (i > 7)
[Link]("Valor de i é maior que 7");
if (op == 2)
[Link]("Opção 2");
op = 0;
[Link]("Opção setada para 0 novamente");
}
if (a != 0 && a % 2 == 0)
[Link]("O valor de a é par!");

if/else

if (i > 7)
[Link]("Valor de i é maior que 7");
else
[Link]("Valor de i é menor ou igual a 7");
if (a != 0 && a % 2 == 0)
imprime Dados ();
[Link]("O valor de a é par!");
}
else
imprimeErro();
[Link]("O valor de a não é par!");
}

else/if

Java 10
 if (a != 0 && a % 2 == 0) {
imprimeDados ();
[Link]("O valor de a é par!");
}else if (a == 0)
[Link]("O valor de a é 0!");
else if (a % 2 != 0)
[Link]("O valor de a é ímpar!");
else
imprimeErro ();

switch/case

public static void main(String args[]) {

int x=1;
switch(x){
case 1:
[Link]("É 1");
break;
case 5:
[Link]("É 5");
break;
case 10:
[Link]("É 10");
break;
default:
[Link]("Nenhum");
}
}

é importante notar a presença do break após cada um dos cases. Ele é

importante para parar o switch, pois depois de entrar em um case, continuará
entrando nos que estiverem abaixo e, inclusive, no default

Comandos de Iteração (while e for)

while

Java 11
 i = 0 ; while (i < 7) {
[Link]("Valor de i é menor que 7");
i++;
}
-------
while (true)
[Link]("Hello world!")
-------
while (x - y <= 15)
x = y * y;

existem casos em que vou precisar usar o break para sair do loop
for

for (int i=0; i<7; i++)

[Link]("Valor de i é menor que 7");

//parênteses seguem a ordem de (valor inicial; condição;

//atualização do valor inicial)

while é usado até a sentença for falsa, já o for corre por determinadas vezes

Associação entre Classes

Tipos de Associação
Associação por composição: Uma classe contém uma ou mais instâncias
de outra classe.

public class Carro {

private Motor motor;
private Roda roda;

public Carro(Motor motor, Roda roda) {

[Link] = motor;
[Link] = roda;

Java 12
 }
}

public class Motor {

private int potencia;

public Motor(int potencia) {

[Link] = potencia;
}
}

public class Roda {

private int tamanho;

public Roda(int tamanho) {

[Link] = tamanho;
}
}

Associação por agregação: Uma classe contém uma ou mais referências a

instâncias de outra classe.

public class Departamento {

private List<Funcionario> funcionarios;

public Departamento() {
[Link] = new ArrayList<>();
}

public void addFuncionario(Funcionario funcionario) {

[Link](funcionario);
}
}

public class Funcionario {

private String nome;

public Funcionario(String nome) {

Java 13
 [Link] = nome;
}
}

Associação por herança: Uma classe herda as características e

comportamentos de outra classe.

public abstract class Veiculo {

private int velocidade;

public Veiculo(int velocidade) {

[Link] = velocidade;
}

public abstract void acelerar();

}

public class Carro extends Veiculo {

public Carro(int velocidade) {
super(velocidade);
}

@Override
public void acelerar() {
[Link]("Acelerando carro...");
}
}

public class Moto extends Veiculo {

public Moto(int velocidade) {
super(velocidade);
}

@Override
public void acelerar() {
[Link]("Acelerando moto...");
}
}

Java 14
 Array
*todas as explicações se tratam de Arrays Unidimensionais, que são
armazenados em uma linha, nem sempre sendo colocas em ordem

Array é uma estrutura na memória que faz com que eu consiga armazenar mais
de uma informação na memória ao mesmo tempo
*todas as variáveis armazenadas em um array precisam ser do mesmo tipo
*todas as variáveis que estão em um array posso acessar pelo mesmo nome
(nome do array)
*cada item do array é um elemento → os elementos são associados a uma
posição numérica

Declarando um Array
*preciso do tipo e do tamanho (quantidade de elementos) para declarar um
array

int[n° de posições] nomeArray;

//ou
int nomeArray[n° de posições];

*eu não posso mudar o tamanho de um array depois que ele já foi criado

Usando um Array
*preciso instanciar

int valorTotal = new int[10];

int valorTotal[0] = 26
int valorTotal[1] = 30

//ou

Java 15
 int valorTotal = {26, 30, ...}

*eu só posso usar um array quando os objetos forem instanciados, ou seja,

quando todos os elementos estejam preenchidos com algum valor

Lendo um Array

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

valorTotal[i] = 0;
//i é a posição e +args[i] é o conteúdo da posição

Verificando se um Array está nulo

if (myArray == null) {
// The array is null
} else {
// The array is not null
}

//ou

import [Link];

// ...

if ([Link](myArray)) {
// The array is null
} else {
// The array is not null
}

Verificando se um elemento de um Array está nulo

Java 16
 if (myArray[i] == null) {
// The element at index i is null
} else {
// The element at index i is not null
}

//ou

String[] myArray = new String[5];

myArray[0] = "Hello";
myArray[1] = null;
myArray[2] = "World";

if (myArray[1] == null) {
[Link]("The element at index 1 is null");
} else {
[Link]("The element at index 1 is not nul
l");
}

Criando um Array de Objetos

Pessoa[]p1 = new Pessoa[4];

//separei um espaço de memória para armazenar 4 objetos
//de pessoa
p1[0] = new Pessoa("José");
p1[1] = new Pessoa("Maria");
p1[2] = new Pessoa("João");
p1[3] = new Pessoa("Ana");

*para pode acessar os métodos preciso do objeto criado → não posso só

reservar espaço na memória e ir criando get e set porque os objetos ainda não
existem
*quando eu apenas reservo o espaço na memória todos os elementos ficam
com o valor padrão, que seria nulo

Java 17
 Verificando se há alguma posição nula em um Array de Objetos

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

if(p1[i] == null)
[Link]("Posição não possui objeto referenci
ado");

Adicionando valores a uma posição de um Array de Objetos

c1[27] = new Carta(7, "ouros"); //insere um objeto diretame

nte
//em uma posição

//ou

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

p1[i] = new Pessoa("Nome da pessoa "+i); //insere objeto
s
//em todas as posições

Array Bidimensional
*são armazenados em forma de tabela/matriz
*cada célula é um elemento

Declarando um Array Bidimensional

int[Linha][Coluna]valorTotal

int valorTotal[Linha][Coluna]

Instanciando um Array Bidimensional de Objetos

Java 18
 valorTotal = new int[10][2]

Percorrendo um Array Bidimensional

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

for (int j = 0; j < myArray[i].length; j++) {
// access each element using myArray[i][j]
[Link](myArray[i][j] + " ");
}
[Link](); // print a newline after each row
}

*uso um laço para linha (i) e outro para coluna (j)

Tratando Exceções
tratamento de exceções precisam aparecem quando o código pode apresentar
algum erro, e para evitá-lo eu lanço (throw) uma exceção
Lançando uma exceção e tratando ela:
*classe de domínio

public class Financeimento{

public double valorTotal;
public double entrada;
public int parcelas;

public financiamento(double valorTotal, double entrada, int

parcelas){
if (entrada < valorTotal * 0.2) {
throw new RuntimeException("A entrada deve ser de no
mínio 20% do valor total)
} else if (parcelas < 6) {
throw new RuntimeException("O número mínio de parcela
s é 6)

Java 19
 }

[Link] = valorTotal;
[Link] = entrada;
[Link] = parcelas;
}
}

*classe principal

public class ProgramaPrincipal{

public static void main(String[]args){
double valorTotal = 1000.0;
double entrada = 300;
double parcelas = 10;

try {
financiamento f = new financiamento(valorTotal, entrad
a, parcelas);
[Link]([Link]());
} catch (RuntimeException e) {
[Link]([Link]());
}
}
}

Nesse código estou criando um objeto financiamento e estou pedindo para que
me mostre o valor da prestação que preciso pagar, já como as regras de
negócio estão na classe de domínio e não pode haver interação com a tela eu
lanço uma exceção. Lançando uma exceção eu preciso aderir o try/catch, que
seria tentar executar certo pedaço de código, e se não for possível eu mostro
as exceções que criei na classe de domínio
Tipo de Exceções
Runtime → pode ser tratada com if/else e a JVM não exige esse tratamento
(unchecked → não precisa do try/catch)
Checked → são situações que o java diz que preciso tratar (para x exceção
usar x coisa)

Java 20
 File no found exception → quer dizer que não conseguiu encontrar o
arquivo

o bom é a maioria das vezes usar as exceções, pois se começo a usar muito
if/else eu começo a perder o controle do que é regra de negócio e o que é um
tratamento de exceção

Java 21