Java — Primeiro Módulo

INTRODUÇÃO
AO JAVA
Fuctura Tecnologia
CAIO VITAL Escola de Software Livre
Lógica de Programação Java
01. Breve História 09. Operadores Aritméticos
02. Instalação 10. Operadores de Atribuição
03. Olá, Mundo! 11. Operadores Relacionais
04. Exibindo Mensagens 12. Operadores Lógicos
05. Sintaxe do Java 13. Estruturas Condicionais
06. Variáveis 14. Laços de Repetição
07. Tipos de Dados 15. Vetores (Arrays)
08. Recebendo Dados 16. Listas: ArrayList
Orientação a Objetos
01. POO 09. Modificadores de Propriedade
02. Método Construtor 10. Modificador Final
03. Encapsulamento 11. Modificador Static
04. Herança 12. Sets (Conjuntos)
05. Polimorfismo 13. Maps (Mapas)
06. Classes Abstratas 14. Lista de Exercícios
07. Interfaces
08. Tratamento de Exceções
 Java — Primeiro Módulo
BREVE HISTÓRIA
Origem e Capacidade
Foi criada pela Sun Microsystems nos anos 90 e se tornou
uma das linguagens mais populares do mundo.

Com Java, é possível criar aplicações rápidas, seguras e robustas.

Java é uma poderosa linguagem de programação que funciona
em diferentes plataformas.

Java está em todo lugar: TVs, celulares, carros e até satélites;

Antes do Java
As linguagens de programação eram divididas em duas categorias:

Compiladas: O código compilado é gerado para um sistema

específico (como Windows ou Linux). Para rodar em outro sistema,
programa precisará ser recompilado.

Interpretadas: o código é interpretado e executado linha por linha

em tempo real. As linguagens interpretadas são mais lentas.
Como o Java funciona?
O código Java é primeiro compilado para um formato intermediário
chamado bytecode. Esse bytecode não é código de máquina
específico de nenhum sistema, tornando-o mais portável.

Interpretação: Em vez de ser executado diretamente pelo sistema

operacional, o bytecode é interpretado pela JVM, que converte
o bytecode em código de máquina específico para o sistema
onde está sendo executado.
Write Once, Run Anywhere
Java roda em qualquer sistema que tenha suporte
à Java Virtual Machine (JVM), ou Máquina Virtual Java.

Ou seja, com a JVM, não importa em qual sistema um programa

foi escrito, seja Windows, Linux ou Mac OS, ele rodará
sem a necessidade de modificações.
Mais sobre o Java
Para executar aplicações desenvolvidas em Java, é preciso
instalar o JRE (Java Runtime Environment).

Para criá-las, é preciso instalar o JDK (Java Development Kit).

O bytecode Java é processado pela JVM. É trabalho

da JVM chamar os recursos necessários ao processador
para executar o bytecode.
 Java — Primeiro Módulo
INSTALAÇÃO
Instalação
Primeiro passo:
Instalar um JDK. Para instalar o JDK no Windows: Link

Segundo passo:
Instalar um Ambiente de Desenvolvimento(IDE): Link
 Primeiro Programa
OLÁ, MUNDO!
Primeiro Programa
➡️
1. Selecione File New ➡️ Java Project
2. Dê um nome ao projeto ➡️ Finish
3. Botão direito do mouse ➡️ pasta src➡️ ➡️
New package
4. Dê um nome ao pacote ➡️ Finish
5. Botão direito do mouse no pacote ➡️ ➡️
New Class
6. Dê um nome à classe ➡️ ➡️
Marque a caixa main Finish
7. Dentro das chaves internas { } escreva o seguinte:
8. [Link]("Olá, mundo!");
 Primeiro Programa
EXIBINDO
UMA MENSAGEM
Instruções [Link]
[Link](“Olá, Mundo!”);
➡️ Imprime o texto e pula uma linha.

[Link](“Olá, Mundo!”);
➡️ Apenas imprime o texto no console.

[Link](“Olá, Mundo!”);
➡️ Imprime um texto que pode ser formatado
 Java — Primeiro Módulo
SINTAXE DO JAVA
O main
Quando executamos um programa Java, o computador
procura automaticamente pelo main e começa a executar
as instruções ali dentro.

É como o arquivo executável(.exe) de um programa.

Sintaxe
Alguns pontos importantes sobre a sintaxe inicial do Java.

Toda instrução ou comando termina com ponto-e-vírgula(;)

O código é delimitado por chaves de abertura e fechamento.

As chaves que vimos no primeiro programa são da classe

e, dentro delas, as chaves do main.
Sintaxe
Java é case sensitive: Isso significa que as palavras-chave,
identificadores e outros elementos da linguagem
são diferenciados por letras maiúsculas e minúsculas.

Convenção de nomes: Em Java usamos o camelCase para nomear

variáveis, métodos e classes. A primeira letra da primeira palavra
é minúscula (exceto em classes) e a primeira letra de cada palavra
subsequente é maiúscula.
 Lógica de Programação
VARIÁVEIS
O que é uma variável?
Uma variável é como uma “caixa” que é usada
para guardar valores de dados.

Esta caixa só pode guardar um único valor por vez.

No entanto, o valor guardado na caixa pode mudar

inúmeras vezes durante a execução do algoritmo.
Variáveis

O que são?
variáveis são estruturas que armazenam dados
na memória durante a execução do programa.

No Java
Java é uma linguagem fortemente tipada. Cada variável
deve ter um tipo declarado antes de ser utilizada.
Declaração

No Java é possível declarar uma varíavel sem valor.

Exemplo de declaração de variável:

➡️ tipo nomeDaVariável
➡️ int idade;
Inicialização

Porém, para que uma variável possa ser utilizada,

será preciso inicializá-la, ou seja, passar
algum valor para ela.

Exemplo de declaração e inicialização

➡️ tipo nomeDaVariável = valor
➡️ int idade = 35;
 Lógica de Programação
TIPOS DE DADOS
Tipos de Dados

Podemos resumir os tipos de dados a três:

1. Tipo Numérico para valores numéricos;

2. Tipo Alfanumérico para valores textuais;
3. Tipo Lógico para valores verdadeiros ou falsos.
Tipos Numéricos

Tipos de dados numéricos representam números

como inteiros ou decimais.

Para armazenarmos um valor inteiro, usamos int.

int idade = 35;
Para armazenarmos um valor decimal, usamos double.
double salario = 2345.69; // separamos com ponto
Tipos Alfanuméricos

Dados alfanuméricos são compostos por caracteres

(letras, números ou sinais gráficos).

Quando queremos armazenar apenas um caractere:

char letra = ‘B’; // usamos aspas simples
Quando queremos armazenar um conjunto de caracteres:
String nome = “Tadeu”; // usamos aspas duplas
Tipo Lógico

O tipo lógico é mais conhecido como booleano.

É um tipo de dado que pode assumir

apenas dois valores: verdadeiro ou falso.

boolean estaLigado = true;

boolean diaUtil = false;
 Lógica de Programação
RECEBENDO DADOS
A classe Scanner

Vamos abstrair uma informação um pouco avançada.

Para recebermos uma entrada de dados do teclado

no Java, precisamos importar da biblioteca
[Link] a classe Scanner e, depois, instanciá-la.
A classe Scanner

Scanner scan = new Scanner([Link]);

[Link]("Qual seu nome? ");

String nome = [Link]();

[Link]("Digite sua idade: ");

int idade = [Link]();
 Lógica de Programação
OPERADORES
ARITMÉTICOS
Operadores Aritméticos

Para somar: Operador de adição +

Para subtrair: Operador de subtração -
Para multiplicar: Operador de multiplicação *
Para dividir: Operador de divisão /
Para o resto de uma divisão: Operador %
Precedência

Os parênteses são usados para definir a ordem

de avaliação.

Em uma expressão, o conteúdo dentro dos parênteses

é avaliado primeiro.
Concatenação

O operador + também tem a função de concatenação:

String nome = “Tadeu”;

String sobrenome = “Silva”;

[Link](nome + sobrenome);
Operadores Unários

Os operadores ++ e -- em Java são usados

para incrementar ou decrementar um valor em 1.

Eles podem ser usados como prefixos ou sufixos.

Operadores Unários

int x = 1; int y = 2;
[Link](x++); [Link](--y);
[Link](x); [Link](y);
[Link](++x); [Link](y--);
 Lógica de Programação
OPERADORES
DE ATRIBUIÇÃO
Operadores de Atribuição

Para definir ou sobrescrever o valor de uma variável,

usamos os operadores de atribuição.

O operador básico é o sinal de igual (=).

Há um operador de atribuição para cada operador

aritmético.
Atribuição com Adição

O operador += soma o valor atual da variável

com outro valor e atribui o resultado de volta à variável.

int x = 5;
x += 3; // Equivalente a x = x + 3, ou seja, x agora vale 8.

Em outras palavras, x recebe ele mesmo acrescido de 3.

Atribuição com Subtração

O operador -= subtrai um valor da variável

e atribui o resultado de volta à variável.

int x = 10;
x -= 4; // Equivalente a x = x - 4, então x agora vale 6.

Em outras palavras, x recebe ele mesmo decrescido de 4.

Atribuição com Multiplicação

O operador *= multiplica o valor da variável

por outro valor e atribui o resultado.

int x = 7;
x *= 2; // Equivalente a x = x * 2, agora x vale 14.

Ou seja, x recebe ele mesmo multiplicado por 2.

Atribuição com Divisão

O operador /= divide o valor da variável

por outro valor e atribui o resultado.

int x = 20;
x /= 5; // Equivalente a x = x / 5, então x agora vale 4.

Em outras palavras, x recebe ele mesmo dividido por 5.

Atribuição com Módulo

O operador %= calcula o resto da divisão da variável

por outro valor e atribui o resultado.

int x = 10;
x %= 3; // Equivalente a x = x % 3, agora x vale 1.

Ou seja, x recebe o resto da divisão dele mesmo por 3.

 Lógica de Programação
OPERADORES
RELACIONAIS
Operadores Relacionais

Operador Relacional é todo operador que obtém a relação

do membro a esquerda com o membro à sua direita.

Estrutura básica

<membro a esquerda> OPERADOR <membro a direita>

Operadores Relacionais

Os operadores relacionais em Java são usados para

comparar dois valores e retornar um valor booleano
(verdadeiro ou falso) como resultado.

Ou seja, cada operação feita com um operador relacional

deverá sempre ter como resultado true ou false.
Operadores Relacionais

Temos 6 operadores relacionais:

Maior que: valor 1 > valor 2
Menor que: valor 1 < valor 2
Maior ou igual a: valor 1 >= valor 2
Menor ou igual a: valor 1 <= valor 2
Igual a: valor 1 == valor 2
Diferente de: valor 1 != valor 2
OPERADORES RELACIONAIS
LEITURA DA
OPERADOR EXPRESSÃO
EXPRESSÃO

== x == y x é igual a y

!= x != y x é diferente de y

> x>y x é maior que y

>= x >= y x é maior ou igual a y

< x<y x é menor que y

<= x <= y x é menor ou igual a y

 Lógica de Programação
A VARIÁVEL
BOOLEANA
A variável booleana true false
uma variável booleana em Java pode armazenar apenas
um dos dois valores: verdadeiro(true) ou falso(false).

Operações lógicas como “a <= b” ou “x > y” resultam

em um valor booleano que pode ser armazenado
em uma variável booleana.
 Lógica de Programação
OPERADORES
LÓGICOS
Operadores Lógicos true false
Os operadores lógicos em Java são utilizados
para avaliar expressões booleanas.

Em Java, usamos três operadores para operações lógicas:

&& (AND), || (OR) e ! (NOT)

Operadores Lógicos true false
O operador && (e comercial ou ampersand) retorna true
somente se ambas as expressões forem verdadeiras.

O operador || (barra vertical ou pipe) retorna true

se pelo menos uma das expressões for verdadeira.

O operador ! inverte o valor da expressão booleana.

 TABELA VERDADE
(&& E ||)

Posso ir à praia?
Proposição A: É um dia de sol.
Proposição B: É final de semana.

Proposição A Proposição B A && B

verdadeiro verdadeiro verdadeiro

verdadeiro falso falso

falso verdadeiro falso

falso falso falso

 TABELA VERDADE
(&& E ||)

Dia de Descanso?
Proposição A: Você está de férias.
Proposição B: É final de semana.

Proposição A Proposição B A || B
verdadeiro verdadeiro verdadeiro

verdadeiro falso verdadeiro

falso verdadeiro verdadeiro

falso falso falso

 Lógica de Programação
ESTRUTURAS
CONDICIONAIS
Estruturas Condicionais

Também conhecidas como Desvio Condicional,

Tomada de Decisão ou mesmo Verificação de Expressões.

As estruturas condicionais são construções comuns

e essenciais no desenvolvimento de software.
Sintaxe

A sintaxe básica é

if (valor booleano/expressão booleana) {

-- instrução a ser executada caso a expressão seja true
}
Sintaxe
Uma estrutura é delimitada por chaves de abertura e fechamento,
ou seja, não é necessário o uso do ponto-e-vírgula.

Instruções: Ações individuais, terminam com ;.

Estruturas: Blocos de código, delimitados por chaves {}.
Sintaxe

if (true) {
-- instrução a ser executada caso a expressão seja true
} else {
-- instrução a ser executada caso a expressão seja false

}
Sintaxe

if (true) {
--instrução a ser executada caso a expressão seja true
} else if (true) {
--instrução a ser executada caso outra expressão seja true
} else {
--instrução a ser executada caso nenhuma seja true
}
Operador Ternário

O operador ternário é um operador condicional

que temos na linguagem Java, juntamente ao if e ao else.

Ele é uma forma resumida para definir uma condição

e escolher por um dentre dois valores.
Operador Ternário

A sintaxe do operador ternário é:

variavel = (condicao) ? valor1 : valor2;

Se a condição for verdadeira, o valor1 é atribuído

à variável. Caso contrário, será atribuído o valor2.
 Lógica de Programação
SWITCH CASE
Switch Case

É uma estrutura de controle que permite testar

condições para determinar qual instrução
será executada em seguida.

É uma forma resumida de escrever múltiplos “if else if”.

Estrutura do Switch Case

switch (expressão) {
case valor1: -- execute esta instrução;
break;
case valor2: -- execute esta instrução;
break;
default: -- execute esta instrução;
Considerações

1. A expressão (variável) usada deve ser inicializada.

2. Deve conter um tipo aceito, como int ou String;
3. Os valores nos cases não podem se repetir.

4. Os valores nos cases não podem ser uma variável.

5. O break encerra a execução do switch.
 Lógica de Programação
LAÇOS
DE REPETIÇÃO
Laços de Repetição

São estruturas que permitem repetir um bloco de código

várias vezes. Também são conhecidas como loops.

São usadas para executar, repetidamente,

uma instrução ou bloco de instrução enquanto
determinada condição estiver sendo satisfeita.
Considerações

Laços de repetição têm quatro elementos fundamentais:

A inicialização define o ponto de partida da repetição.

A condição define o momento de parada da repetição.
O corpo contém as instruções que devem se repetir.
A iteração atualiza a contagem para a próxima repetição.
O laço de repetição While

O while(enquanto) executa um bloco de código enquanto

uma condição for verdadeira.

A condição é testada antes.

Sendo verdadeira, o bloco de código será executado.

O processo é repetido até que a condição se torne falsa.
A estrutura do laço while

while(condição verdadeira) {

-- instrução a ser executada;

-- variável de controle;
//O laço deve conter a lógica que torna a condição falsa.
}
O laço de repetição Do While

No caso do laço do-while, o bloco de código é executado

pelo menos uma vez, mesmo que a condição seja falsa.

Depois dessa execução, a condição é testada

e o processo se repete até que ela se torne falsa.
A estrutura do laço do while

do {

-- instrução a ser executada;

-- variável de controle;
//O laço deve conter a lógica que torna a condição falsa.
} while (condição verdadeira);
O laço de repetição For

usado para executar um bloco de código

um número específico de vezes.

A quantidade de repetições é determinada

durante a estruturação deste laço.
A estrutura do laço for

for (inicialização; condição; iteração) {

-- instrução a ser executada;

}
Dentro da estrutura haverá a determinação do início,
a condição de parada e a maneira como deve iterar.
Comandos break e continue

São muito usados em estruturas de repetição;

O Continue serve para ignorar trechos de código.

O Break é utilizado para sair de uma estrutura.

Comandos break e continue

for (int i = 0; i < 10; i++) { for (int i = 0; i < 10; i++) {
if (i == 4) { if (i == 4) {
break; continue;
} }
[Link](i); [Link](i);
} }
 Lógica de Programação
VETORES
OU ARRAYS
Vetores ou Arrays

Arrays, como são conhecidos pelo Java, podem ser

identificados como uma coleção ordenada de valores
de um único tipo.

Os valores em um array são chamados de elementos

e são acessados por meio de índices numéricos inteiros.
Sintaxe

tipo[] nomeDoArray = new tipo[tamanho];

int[] valores = new int[5];

Onde tipo é o tipo de dados dos elementos do array,

nomeDoArray é o nome dado ao array e tamanho
é o número de elementos que o array pode armazenar.
Observações

Um array não precisa ser inicializado ao criar,

mas também não poderá ser utilizado.

Quando um array é declarado, cada elemento

recebe um valor padrão: 0 para números,
false para booleanos e null para referências.
Sintaxe

Ao declarar um array, é preciso especificar seu tamanho.

double[] notas = new double[6];

String[] alunos = new String [3];

Todo índice de um array começa em 0.

Formas de Declaração

tipo[] nomeDoArray = new tipo[tamanho];

tipo[] nomeDoArray;
nomedoArray = new tipo[tamanho];

tipo[] nomeDoArray = new tipo[] {valor1, valor2, valor3...};

Esta última forma define o tamanho do array pela
quantidade de valores inseridos entre as chaves;
Acessando Posições

String [] nomes = new String [3];

nomes [0] = “José”;

nomes [1] = “Maria”;

[Link] (nomes[0]);
 Lógica de Programação
LISTAS:
ARRAYLISTS
Listas, Lists ou ArrayLists

São uma coleção de elementos em ordem linear.

Uma Lista pode ser mantida ordenada ou não.

As operações mais comuns de uma coleção

do tipo Lista são: adição, remoção, acesso a elementos,
pesquisa e quantidade de elementos.
Listas, Lists ou ArrayLists

Assim como o Scanner, para usar uma ArrayList, será

preciso importar dois elementos da biblioteca [Link],
que são a List e a ArrayList. No Eclipse, podemos usar
o atalho CTRL + SHIFT + O para organizar as importações.

import [Link];
import [Link];
Sintaxe

List<tipo> nomeDaVariavel;
nomeDaVariavel = new ArrayList<>();

OU

List<tipo> nomeDaVariavel = new ArrayList<>();

Métodos Comuns

Método add (adicionar) ➡️ [Link](elemento);

Método get (acessar/pegar) ➡️ [Link](elemento);
Método remove (remover) ➡️ [Link](elemento);
Método set (alterar) ➡️ [Link](posição, novoElemento);
Método contains (contém) ➡️ [Link](elemento);
Método size (tamanho) ➡️ [Link]();
 Lógica de Programação
CLASSES
INVÓLUCRO
Wrapper Classes

Tipos primitivos como int, char, double, são eficientes

em termos de desempenho, mas não podem ser usados
diretamente em coleções, porque essas coleções
trabalham apenas com objetos.
Wrapper Classes

Para resolver esse problema, o Java oferece as Classes

Invólucro (ou Wrapper Classes), que são versões objeto
dos tipos primitivos.

Elas permitem que tratar os tipos primitivos

como objetos, possibilitando o uso deles em coleções.
Wrapper Classes

Cada tipo primitivo tem sua classe invólucro

correspondente:

int ➡️ Integer
char ➡️ Character
double ➡️ Double
boolean ➡️ Boolean
 Lógica de Programação
FOR EACH
(PARA CADA)
For Each

O for each é uma estrutura de repetição que permite

percorrer cada elemento de uma coleção, como listas,
de forma simples e clara.
Sintaxe

A sintaxe básica do for each é a seguinte:

for (tipoElemento elemento : colecao) {

// Bloco de código a ser executado para cada elemento
}
tipoElemento é o tipo de dados dos elementos, que são
variáveis que representarão cada item na coleção.
Exemplo de Uso

String[] frutas = {"maçã", "banana", "laranja"};

for (String fruta : frutas) {

[Link]("Fruta: " + fruta);
}

O código acima exibirá uma linha para cada fruta.

Quando Usar?

Quando você deseja percorrer todos os elementos

de uma coleção e não precisa modificar a coleção
durante a iteração.

Quando a ordem dos elementos é importante

(como em um List).
Limitações

Não é indicado quando precisamos modificar a coleção,

como, por exemplo, quando precisamos adicionar
ou remover elementos durante a iteração.

Não fornece um índice do elemento atual,

o que pode ser necessário em algumas situações.
 Java - Primeiro Módulo
PROGRAMAÇÃO
ORIENTADA
A OBJETOS
Introdução

Sistemas grandes são difíceis de gerenciar.

Para facilitar o controle, é uma boa prática dividi-los

em partes menores e separar suas responsabilidades.

Isso não só melhora a organização, mas também facilita

a manutenção e a flexibilidade do sistema.
Introdução

Fazemos isso usando objetos, que têm atributos

e métodos, todos definidos dentro de classes.
As classes, por sua vez, são organizadas em pacotes.

Esses conceitos são fundamentais em Java

e são sempre usados ao programar nessa linguagem.
Classes

Uma classe é uma estrutura que abstrai um conjunto

de objetos com características similares.

Uma classe define as propriedades dos seus objetos

através de atributos e possíveis comportamentos
desses objetos através de métodos.
Atributos

Atributos são características que uma classe pode ter.

A classe Gato, por exemplo, poderia ter os atributos:

String nome;
double peso;
String corDoPelo;
Métodos

Métodos são os comportamentos que uma classe pode ter.

A classe Gato, por exemplo, poderia ter os métodos:

comer();
dormir();
miar();
Instâncias/Objetos

Um objeto é, em tempo de execução,

uma instância de uma classe na memória.

Utilizamos a palavra reservada new

para criar uma nova instância.

Gato tadeu = new Gato(); // Objeto na memória

Instâncias/Objetos

A variável de referência nesse momento aponta para

um novo objeto do tipo Gato na memória.

Quando uma variável de determinado tipo é declarada,

foi declarada uma referência para determinado objeto.

Gato tadeu; // Foi declarada uma variável de referência.

Criando a classe Gato

public class Gato {

String nome; // atributo do tipo String

double peso; // atributo do tipo double
String corDoPelo; // atributo do tipo String
Criando a classe Gato

public void comer() { // método comer

[Link]("O gato está comendo.");

}
public void miar() { // método miar
[Link]("Miau!");
Componentes de um Método

Nome: utilizado para chamar o método;

Lista de parâmetros: Define os valores que o método
vai receber. Pode ser nenhum ou n.
Corpo: Define o que vai acontecer quando o método
for chamado;
Retorno: A resposta que será devolvida ao final
do processamento do método. Pode ser void (vazio).
Componentes de um Método

retorno nome (parâmetros) {

void depositar (double valor) {

saldo += valor;
}
objeto de referência ➡️ Conta c = new Conta();
invocando o método ➡️ [Link](499.95);
A palavra-chave THIS

É muito usada dentro de métodos que recebem

parâmetros com o mesmo nome de atributos
de instância da classe para diferenciar entre os dois.

Ou seja, se um parâmetro de um método

recebe o mesmo nome de um atributo da classe,
é ideal usar o this para diferenciá-los.
A palavra-chave THIS

class Funcionario {
double salario;

double calcularAumento(double porcentagem) {

return [Link] * porcentagem / 100;
}
A palavra-chave THIS

void aumentarSalario(double porcentagem) {

double aumento = [Link](porcentagem);
[Link] += aumento;
}
 Java - Primeiro Módulo
O MÉTODO
CONSTRUTOR
O método construtor

Construtores são métodos especiais usados

para inicializar um objeto.

São chamados na criação do objeto, ao usarmos

a palavra-chave new.
O método construtor

O construtor tem o mesmo nome da classe

e não tem um tipo de retorno.

É possível ter vários construtores em uma classe

com diferentes números de parâmetros.

Garantem que objeto seja válido no momento da criação.

O método construtor

Caso um construtor não seja declarado, uma classe

tem um construtor vazio implícito, gerado a partir
do momento da criação da classe.

Porém, caso seja declarado um construtor com qualquer

parâmetro, o construtor vazio deixa de ser implícito
e passa a ser necessária a declaração para ser usado.
O método construtor

public Gato() { }

public Gato (String nome, double peso, String corDoPelo) {

[Link] = nome;
[Link] = peso;
[Link] = corDoPelo;
}
 Java - Primeiro Módulo
ENCAPSULAMENTO
Encapsulamento

Encapsulamento é um dos conceitos fundamentais

de Programação Orientada a Objetos.

Ele permite que os dados e o código que age sobre eles

sejam agrupados em uma única unidade, protegendo
os membros de uma classe de serem acessados
por outras classes.
Encapsulamento

O encapsulamento ajuda a manter o código organizado

e fácil de entender, além de aumentar a segurança
e a flexibilidade dos sistemas.

O encapsulamento é implementado através

do uso de modificadores de acesso.
Implementação

Os principais modificadores são:

public
membros marcados como public podem ser acessados
por qualquer classe dentro do projeto.
Implementação

Os principais modificadores são:

private
membros marcados como private só podem ser acessados
pela própria classe em que foram definidos.
Implementação

Os principais modificadores são:

protected
membros marcados como protected podem ser acessados
pela própria classe em que foram definidos e por suas
subclasses.
Métodos Getters e Setters

Os métodos “getters” são usados para acessar

os valores dos atributos de uma classe
de maneira controlada.

O método “getter” geralmente tem o nome get seguido

pelo nome do atributo com a primeira letra maiúscula.
private String nome; ➡️ public String getNome( )
Métodos Getters e Setters

Os métodos “setters” são usados para modificar

os valores dos atributos de uma classe
de maneira controlada.

O método “setter” geralmente tem o nome set seguido

pelo nome do atributo com a primeira letra maiúscula.
private String nome; ➡️ public void setNome( )
Aplicação

public class Conta {

private String titular;
private double saldo;

public String getTitular() {

return titular;
}
Aplicação

public void setTitular(String titular) {

[Link] = titular;
}

public double getSaldo() {

return saldo;
}
 Java - Orientação a Objetos
HERANÇA
Herança

Herança é um conceito fundamental da programação

orientada a objetos que permite que uma classe
herde os atributos e métodos de outra classe.

Isso permite criar uma nova classe com base

em uma classe existente e reutilizar seu código.
Herança

A nova classe é chamada de subclasse ou classe filha;

a classe existente é chamada de superclasse
ou classe pai/mãe.

A herança permite a criação de hierarquias de classes

e organização de código de maneira mais eficiente.
Implementação

A implementação utiliza a palavra-chave extends.

Para criar uma subclasse, usa-se a sintaxe:

class Subclasse extends Superclasse

Em Java, uma classe só pode herdar de uma outra classe,

ou seja, não existe herança múltipla.
Implementação

public class Animal {

private String nome;
private String peso;

public Animal (String nome, double peso) {

[Link] = nome;
[Link] = peso;
Implementação

public class Gato extends Animal {

private String raca;

public Gato(String nome, double peso, String raca) {

super(nome, peso); // chamando o construtor de Animal
[Link] = raca;
}
Implementação

public class Cachorro extends Animal {

private String pelo;

public Cachorro(String nome, double peso, String pelo) {

super(nome, peso); // chamando o construtor de Animal
[Link] = pelo;
}
 Java - Orientação a Objetos
POLIMORFISMO
Polimorfismo

É o terceiro pilar da Programação Orientada a Objetos.

Permite que um objeto possa agir de forma diferente

ou que um objeto possa ser tratado como se fosse
de outro tipo. Isso significa que um objeto pode ter
várias formas e comportamentos diferentes.
Polimorfismo

Isso é possível porque a subclasse herda os métodos

e propriedades da superclasse e pode sobrescrever
ou adicionar novos comportamentos.

O polimorfismo possibilita tornar o código mais flexível.

Polimorfismo Estático

public class Calculadora {

public int somar(int num1, int num2) {

return num1 + num2;
}
(...)
Polimorfismo Estático

public double somar(double num1, double num2) {

return num1 + num2;

}
Polimorfismo Estático

O Polimorfismo Estático pode ser aplicado

em métodos dentro de uma mesma classe.

Também conhecido como sobrecarga ou overload.

No exemplo, o nome do método é o mesmo,

mas os parâmetros são de tipos diferentes.
Polimorfismo Dinâmico

public class CalcEspecial extends Calculadora {

public double somar(double a, double b) {

[Link]("Usando a calculadora
especial para somar");
return [Link](a, b);
(...)
Polimorfismo Dinâmico

@Override
public double somar(double a, double b) {
[Link]("Usando a calculadora
especial para somar");
return [Link](a, b);
}
Polimorfismo Dinâmico

O Polimorfismo Dinâmico é aplicado em métodos

herdados da superclasse.

É também conhecido como sobrescrita ou override.

No exemplo, o nome e os parâmetros são os mesmos,

mas a implementação é diferente.
 Java - Orientação a Objetos

CLASSES
ABSTRATAS
Classes Abstratas

Uma classe abstrata é uma classe base que não pode

ser instanciada, mas que fornece uma estrutura
comum para outras classes que a estendem.

Pode conter métodos abstratos que devem

ser implementados pelas subclasses,
garantindo consistência entre elas.
Classes Abstratas

As classes abstratas são usadas para evitar a duplicação

de código, auxiliar na herança e no polimorfismo
e fornecer uma estrutura básica para as subclasses.

Em outras palavras, é uma classe que serve de modelo

para outras classes.
Classes Abstratas

Utilizada a palavra-chave abstract;

➡️ public abstract class Carro { } ⬅️ classe abstrata
➡️ public abstract void acelerar( ); ⬅️ método abstrato

1. Classes abstratas não podem ser instanciadas.

2. Podem ou não ter métodos abstratos.

Métodos Abstratos

Métodos abstratos são métodos que não podem ter corpo.

Um método abstrato obriga que a classe seja abstrata.

A subclasse concreta de uma classe abstrata

deve implementar todos os métodos abstratos.
Na Prática

public abstract class Veiculo {

String marca;
String modelo;

public abstract void abastecer();

Na Prática

public class Carro extends Veiculo {

@Override
public void abastecer() {
[Link](“Abastecendo o carro com gasolina”);

}
Na Prática

public class ScooterEletrica {

@Override
public void abastecer() {
[Link](“Carregando a scooter na tomada”);

}
 Java - Orientação a Objetos
INTERFACES
Interfaces

Interfaces são classes completamente abstratas.

São geralmente usadas para especificar comportamentos

que as classes que a implementam devem por em prática.
Interfaces

Quando implementamos uma interface, sabemos

exatamente quais métodos precisamos fornecer.

Isso cria um contrato claro que facilita a organização

e o planejamento do código.
Interfaces

Para declarar uma interface, usamos a palavra-chave

interface no lugar de class.

1. A classe que implementar usará a palavra implements;

2. Não podem ser instanciadas, apenas implementadas;
3. Uma classe pode implementar mais de uma interface;
Na Prática

public interface Ferramenta {

// Métodos que devem ser implementados pelas classes

void usar();
void guardar();

}
Na Prática

public class Martelo implements Ferramenta {

@Override
public void usar() {
[Link]("O martelo está sendo usado
para bater pregos.");
}
Na Prática

@Override
public void guardar() {
[Link]("O martelo foi guardado na caixa
de ferramentas.");
}
}
Na Prática

public class Serra implements Ferramenta {

@Override
public void usar() {
[Link]("A serra está sendo usada
para serrar madeira.");
}
Na Prática

@Override
public void guardar() {
[Link]("A serra foi guardada no painel
de serras");
}
}
Diferenças

A principal diferença entre classes abstratas

e interfaces é que classes abstratas podem conter
atributos e métodos, enquanto interfaces
geralmente contém apenas métodos.

Uma classe pode herdar apenas de uma outra classe,

enquanto uma classe pode implementar várias interfaces.
Quando usar?

Classe Abstrata: Usada quando há uma relação

hierárquica clara, onde uma classe base compartilha
atributos e comportamentos com suas subclasses.

Interface: Usada para definir um contrato que várias

classes diferentes podem seguir, independentemente
de suas posições na hierarquia de herança.
Exemplos - Classes Abstratas

Para definir uma base para um conjunto de classes.

Para definir um comportamento que pode

ser compartilhado por um conjunto de classes.

Para forçar as classes a implementar um determinado

comportamento.
Exemplos - Interfaces

Para definir um contrato que as classes devem

cumprir.

Classes diferentes podem ser tratadas como instâncias

da mesma interface, facilitando o polimorfismo.

Para simplificar a implementação de um componente.

 Java - Primeiro Módulo
TRATAMENTO
DE EXCEÇÕES
Tratamento de Exceções

O tratamento de exceções em Java é um mecanismo

que permite ao programador lidar com erros e exceções
que podem ocorrer durante a execução de um programa.

Isso é feito através do uso de blocos try, catch e finally,

além de palavras-chave como throw e throws.
Tratamento de Exceções

try {
-- códigos que podem gerar uma situação de exceção.
} catch (Exception ex) {
bloco de tratamento associado à condição de exceção
Exception ou as subclasses, identificada pelo objeto ex
}
Tratamento de Exceções

finally {
bloco de código que sempre será executado, havendo ou
não exceções (Não é obrigatório na estrutura)
Tratamento de Exceções

Observe o método abaixo:

public double dividir (int a, int b) {

return a / b;
}
Se "b" for igual a zero, ocorrerá uma exceção do tipo
"ArithmeticException" no momento da divisão.
Tratamento de Exceções

try {
double resultado = dividir (10, 0);
[Link](”O resultado é “ + resultado);

} catch (ArithmeticException ex) {

[Link]("Impossível dividir por zero");
}
 Java - Primeiro Módulo
THROW / THROWS
Throw

A palavra-chave throw é usada para lançar

manualmente uma exceção.
Podemos usar isso ao detectarmos uma situação
em que desejamos forçar uma exceção a ocorrer.

Com throw, podemos criar e disparar uma exceção

no momento desejado.
Sintaxe

throw new TipoDeExcecao("Mensagem de erro");

Vamos reescrever o método dividir(int a, int b) {}

Sintaxe

public double dividir(int a, int b) {

if (b == 0) {
throw new ArithmeticException("Não é possível
dividir por zero!");
}
return a / b;
}
Sintaxe

try {
double resultado = dividir(10, 0);
[Link]("O resultado é: " + resultado);
} catch (ArithmeticException ex) {
[Link]("Erro: " + [Link]());
// Vai imprimir "Erro: Não é possível dividir por zero!"
}
Throws

A palavra-chave throws é usada na assinatura

de um método para indicar que ele pode lançar
determinadas exceções.

Ela é uma forma de avisar o programador que,

ao chamar aquele método, ele precisa lidar
com uma possível exceção.
Sintaxe

public void nomeDoMetodo() throws TipoDeExcecao {

// código que pode lançar a exceção
}

Isso não muda o comportamento do método,

mas informa que quem o chamar deve estar
preparado para tratar essa exceção.
Sintaxe
public double dividir(int a, int b) throws
ArithmeticException {
if (b == 0) {
throw new ArithmeticException("Não é possível
dividir por zero!");
}
return a / b;
}
Throws

Se um método está marcado com throws, significa

que quem chamar esse método deve estar preparado
para tratar a exceção ou propagar a exceção adiante.

Isso ajuda a manter o código mais robusto, pois

o programador sabe antecipadamente que o método
pode falhar em determinadas situações.
Throws - Sem Try/Catch

public static void main(String[] args) {

//vai lançar ArithmeticException e encerrar o programa
double resultado = dividir(10, 0);

[Link]("O resultado é: " + resultado);

// Não será executado
}
Throws - Com Try/Catch

try {
double resultado = dividir(10, 0); // Pode lançar exceção
[Link]("O resultado é: " + resultado);
} catch (ArithmeticException ex) { // Tratamento
[Link]("Erro: " + [Link]());
}
 Java - Primeiro Módulo
MODIFICADORES
DE PROPRIEDADE
Modificadores Final e Static

Os modificadores final e static são palavras-chave

que controlam características de classes, métodos
e variáveis, garantindo organização e segurança
no código.
 Java - Primeiro Módulo
MODIFICADOR
FINAL
Modificador Final

O modificador final em Java pode ser usado em variáveis,

métodos e classes.

O comportamento muda dependendo de onde é aplicado.

Modificador Final

Quando você declara uma variável como final,

está dizendo que o valor dela não pode ser alterado
depois de ser inicializado, como uma constante.

Se for uma variável de objeto (não primitiva), o que fica

constante é a referência ao objeto, mas os atributos do
objeto podem mudar.
Final em variáveis

final int idade = 30;

idade = 35; // Isso vai dar erro, pois idade é final.

Final em variáveis

final Pessoa pessoa = new Pessoa("Carlos");

// Podemos mudar o nome da pessoa
[Link]("Ana");
[Link]([Link]); // Vai imprimir "Ana"
// Não podemos fazer 'pessoa' apontar para outro objeto
pessoa = new Pessoa("João"); // Isso vai dar erro
Modificador Final

Um método marcado como final não pode ser sobrescrito

(ou seja, reescrito) por uma classe filha.

Por fim, quando uma classe é marcada como final,

significa que ninguém pode herdar dessa classe.
Final em Métodos

public class Utilidades {

public final void mostrarMensagem() {
[Link]("Exemplo de mensagem");
}

Não seria possível a uma subclasse fazer o @Override

de um método final herdado da superclasse.
Final em Classes

final class Utilidades {

public static void mostrarMensagem() {
[Link]("Exemplo de mensagem");
}

// Não é possível estender uma classe final.

class OutraUtilidade extends Utilidades { }
 Java - Primeiro Módulo
MODIFICADOR
STATIC
Modificador Static

O modificador static é usado principalmente

em variáveis e métodos.

Ele significa que o membro da classe pertence à própria

classe e não a uma instância específica da classe.
Modificador Static

Uma variável static é compartilhada

por todas as instâncias da classe.

Se um objeto alterar o valor dessa variável,

todas as instâncias verão a mudança.
Modificador Static

class Contador {
public static int total = 0;

public Contador() {
total++; // Quando um objeto é criado, o total aumenta
}
}
Modificador Static

Contador c1 = new Contador();

Contador c2 = new Contador();
[Link]([Link]);

// Vai imprimir 2, pois é a mesma variável para todos.

Modificador Static

Um método static pode ser chamado sem precisar

criar um objeto da classe.

Ele pertence à classe em si, e não a um objeto específico.

Modificador Static

class Matematica {
public static int somar(int a, int b) {
return a + b;
}
}
// Não precisa criar um objeto para usar o método
[Link]([Link](3, 5));
Modificador Static

Um bloco static é executado uma vez quando a classe

é carregada na memória, mesmo antes de qualquer
instância ser criada.
Modificador Static

class Inicializacao {
static {
[Link]("Bloco static executado!");
}
}
Inicializacao obj1 = new Inicializacao(); // Ao criar o
primeiro objeto, o bloco static já terá sido executado
 Java - Primeiro Módulo
COMPLEMENTOS
 Java - Primeiro Módulo
SETS
Sets ou Conjuntos

Set é uma coleção que não permite elementos duplicados

e também não garante ordem de inserção, a menos
que uma implementação específica seja usada,
como o LinkedHashSet.

As operações mais comuns em um Set são: adição,

remoção, pesquisa e verificação de existência.
Sets ou Conjuntos

Assim como em outras coleções, é preciso importar

o Set e a sua implementação da biblioteca [Link].

import [Link];
import [Link];
Sintaxe do Set

Set<tipo> nomeDaVariavel;
nomeDaVariavel = new HashSet<>();

OU

Set<tipo> nomeDaVariavel = new HashSet<>();"

Métodos Comuns

Método add ➡️ [Link](elemento);

Método remove ➡️ [Link](elemento);
Método contains ➡️ [Link](elemento);
Método size ➡️ [Link]();
Método isEmpty ➡️ [Link]();
 Java - Primeiro Módulo
MAPS
Map

Map é uma coleção que armazena pares de chave-valor.

Cada chave é única, mas os valores podem ser duplicados.

As operações mais comuns em um Map são: adicionar,

remover, acessar valores a partir de chaves
e verificar se uma chave existe.
Map

Para usar Map, é necessário importar o Map

e sua implementação da biblioteca [Link].

import [Link];
import [Link];
Sintaxe do Map

Map<chave, valor> nomeDaVariavel;

nomeDaVariavel = new HashMap<>();

OU

Map<chave, valor> nomeDaVariavel = new HashMap<>();

Sintaxe do Map

Método put ➡️ [Link](chave, valor);

Método get ➡️ [Link](chave);
Método remove ➡️ [Link](chave);
Método containsKey ➡️ [Link](chave);
Método containsValue ➡️ [Link](valor);
Método size ➡️ [Link]();
 Fuctura Tecnologia
Escola de Software Livre

Java - Primeiro Módulo

OBRIGADO!