E-book da Unidade - Programação Java

Prévia do material em texto

PROGRAMAÇÃO 
CODING (MOBILE)
Unidade 2
Programação Java
CEO 
DAVID LIRA STEPHEN BARROS
Diretora Editorial 
ALESSANDRA FERREIRA
Gerente Editorial 
LAURA KRISTINA FRANCO DOS SANTOS
Projeto Gráfico 
TIAGO DA ROCHA
Autoria 
LUIZ FERNANDO CORCINI
4 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
A
U
TO
RI
A
Luiz Fernando Corcini
Olá. Sou graduado em Engenharia Eletrônica, com 
especialização em Administração de TI; mestre em Educação 
e Novas Tecnologias; e doutorando em Sistemas Tutores 
Inteligentes. Tenho experiência técnico-profissional na área de 
desenvolvimento e gestão da produção de softwares nas áreas 
de Gerenciamento de Processos Empresariais e uso os recursos 
disponibilizados pela web há mais de 20 anos.
Sou professor universitário há mais de 15 anos e já 
publiquei vários livros técnicos sobre assuntos voltados a área 
de informática. Sou apaixonado pelo que faço e adoro transmitir 
minha experiência de vida àqueles que estão iniciando em suas 
profissões. Por isso, fui convidado pela Editora Telesapiens a 
integrar seu elenco de autores independentes.
Estou muito feliz em poder ajudar você nesta fase de muito 
estudo e trabalho. Conte comigo!
5PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
ÍC
O
N
ESEsses ícones aparecerão em sua trilha de aprendizagem nos seguintes casos:
OBJETIVO
No início do 
desenvolvimento 
de uma nova 
competência. DEFINIÇÃO
Caso haja a 
necessidade de 
apresentar um novo 
conceito.
NOTA
Quando são 
necessárias 
observações ou 
complementações. IMPORTANTE
Se as observações 
escritas tiverem que 
ser priorizadas.
EXPLICANDO 
MELHOR
Se algo precisar ser 
melhor explicado ou 
detalhado. VOCÊ SABIA?
Se existirem 
curiosidades e 
indagações lúdicas 
sobre o tema em 
estudo.
SAIBA MAIS
Existência de 
textos, referências 
bibliográficas e links 
para aprofundar seu 
conhecimento.
ACESSE
Se for preciso acessar 
sites para fazer 
downloads, assistir 
vídeos, ler textos ou 
ouvir podcasts. 
REFLITA
Se houver a 
necessidade de 
chamar a atenção 
sobre algo a 
ser refletido ou 
discutido.
RESUMINDO
Quando for preciso 
fazer um resumo 
cumulativo das últimas 
abordagens.
ATIVIDADES
Quando alguma 
atividade de 
autoaprendizagem 
for aplicada. TESTANDO
Quando uma 
competência é 
concluída e questões 
são explicadas.
6 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
SU
M
Á
RI
O
Java básico ............................................................................... 10
O primeiro projeto Java ....................................................................................10
A primeira classe Java .........................................................................14
Estrutura básica da linguagem Java................................................................20
Estrutura de um programa Java .......................................................21
Identificadores .....................................................................................23
Palavras reservadas ............................................................................25
Variáveis ................................................................................................25
Tipos de dados simples .....................................................................27
Tipos de dados compostos ...............................................................30
Conversão de tipos .............................................................................31
Escopo de variável ..............................................................................34
Modificadores de acesso ...................................................................35
Operadores ..........................................................................................41
Estrutura de controle de seleção ........................................... 48
Comando if ..........................................................................................................48
Comando if-else ..................................................................................................49
Condições mais elaboradas .............................................................................50
O comando switch ..............................................................................................51
Estrutura de controle de repetição ................................................................53
Controlando loops .............................................................................................56
7PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Classes em Java........................................................................ 60
Introdução ...........................................................................................................60
Métodos ...............................................................................................................60
Classes .................................................................................................................64
Polimorfismo, interface e classes abstratas......................... 75
Polimorfismo .......................................................................................................75
Interface ..............................................................................................................81
Declarando uma interface .................................................................81
Classes abstratas ...............................................................................................83
8 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
A
PR
ES
EN
TA
ÇÃ
O
Seja bem-vindo (a) à Unidade 2 da disciplina de 
Programação Coding Mobile. Nesta unidade, abordaremos os 
conceitos fundamentais de programação Java necessários para 
que você possa desenvolver aplicativos nesta linguagem. Vale 
ressaltar que, apesar de o foco da disciplina ser a programação 
para dispositivos móveis, os conceitos apresentados serão úteis 
mesmo para programação Java em qualquer ambiente.
O conteúdo está dividido em quatro módulos. No 
primeiro, apresentamos a sintaxe das instruções básicas do Java 
para a manipulação de variáveis e outros recursos elementares da 
linguagem. No segundo, estudaremos as estruturas de controle 
e repetição de fluxo. No terceiro, aprenderemos como trabalhar 
com classes em Java. Finalmente, no quarto, abordaremos 
conceitos fundamentais da programação orientada a objetos, 
como polimorfismo, classes abstratas e interfaces.
É claro que há muito mais a aprender, mas o 
aprofundamento de cada um desses conhecimentos pode ser 
feito acessando os links indicados durante o texto, no tópico “Saiba 
Mais”. Vamos começar? Excelente estudo para você!
9PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
O
BJ
ET
IV
O
S
Olá. Seja muito bem-vindo à Unidade 2. Nosso objetivo 
é auxiliar você no desenvolvimento das seguintes competências 
profissionais até o término desta etapa de estudos:
1. Reconhecer a sintaxe das instruções básicas do Java 
para manipulação de variáveis e outros recursos 
elementares da linguagem.
2. Explicar as estruturas de controle e repetição de fluxo 
de código na linguagem Java.
3. Aplicar os conceitos de programação orientada a 
objetos na linguagem Java, com foco nas classes de 
objetos.
4. Identificar e aplicar os conceitos de polimorfismo, 
classes abstratas e interfaces na linguagem Java.
Vamos, então, rumo ao conhecimento. Bons estudos!
10 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Java básico
OBJETIVO
Ao término deste capítulo, você será capaz de 
entender como funciona a sintaxe básica da 
linguagem de Programação Java. E então? Motivado 
para desenvolver esta competência? Então vamos 
lá. Avante!
IMPORTANTE
Salientamos que os conceitos apresentados 
podem sofrer algumas modificações devido a 
atualizações.
Apesar de o foco desta disciplina ser programação para 
aplicativos móveis, o conteúdo apresentado nesta unidade serve 
como base em programaçãoVerifique os links e livros indicados nas referências bibliográficas, 
com destaque para os livros de Deitel (2003) e Mattos (2007).
86 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
RESUMINDO
E então? Gostou do que lhe mostramos? Aprendeu 
mesmo tudinho? Agora, só para termos certeza de 
que você realmente entendeu o tema de estudo 
deste capítulo, vamos resumir tudo o que vimos. 
Você deve ter aprendido sobre o polimorfismo, 
a interface e as classes abstratas, bem como 
aprendeu como declarar uma interface.
87PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
RE
FE
RÊ
N
CI
A
S
AMAR, R. Android. Hardware.com.br, 2009. Disponível em: www.
hardware.com.br/livros/smartphones/android.html. Acesso em: 
08 dez. 2023.
CLARO, D.; SOBRAL, J. Programação em JAVA. Florianópolis: 
Copyleft Pearson Education, 2008. Disponível em: http://www.
faeterj-rio.edu.br/downloads/bbv/0031.pdf. Acesso em: 08 dez. 
2023.
CORDEIRO, F. Android Aprendiz: o guia definitivo para tornar-se 
um desenvolvedor android profissional e independente. 5. ed. [S. l.]: 
AndroidPro, 2017. Disponível em: https://www.studocu.com/pt-br/
document/universidade-federal-do-rio-grande-do-sul/introducao-
a-programacao/ebook-android-aprendiz-novo/5540556. Acesso 
em: 08 dez. 2023.
DALL’OGLIO, P. PHP: programando com orientação a objetos. São 
Paulo: Novatec Editora, 2016.
DEITEL, H.; DEITEI, P. Java: como programar. Porto Alegre: 
Bookman, 2003.
ESCOPO. In: Dicionário Priberam da Língua Portuguesa. Lisboa: 
Priberam Informática, S.A., 2023. Disponível em: https://
dicionario.priberam.org/pesquisar/escopo#:~:text=Limite%20
ou%20abrangência%20de%20uma,da%20campanha).%20
...&text=alvo%20%7C%20n.%20m.%20%7C%20adj.,%7C%20adj. 
Acesso em: 23 jan. 2024.
GOSLING, J.; McGILTON, H. The Java language environment. 
Mountain View, California, EUA: Sun Microsystems, Inc, 1995.
MATTOS, E. Programação de softwares em Java. São Paulo: 
Digerati Books, 2007.
ORACLE. About the Java technology. Oracle, 2018. Disponível 
em: https://docs.oracle.com/javase/tutorial/getStarted/intro/
definition.html. Acesso em: 08 dez. 2023.
	Java básico
	O primeiro projeto Java
	A primeira classe Java
	Estrutura básica da linguagem Java
	Estrutura de um programa Java
	Identificadores
	Palavras reservadas
	Variáveis
	Tipos de dados simples
	Tipos de dados compostos
	Conversão de tipos
	Escopo de variável
	Modificadores de acesso
	Operadores
	Estrutura de controle de seleção
	Comando if
	Comando if-else
	Condições mais elaboradas
	O comando switch
	Estrutura de controle de repetição
	Controlando loops
	Classes em Java
	Introdução
	Métodos
	Classes
	Polimorfismo, interface e classes abstratas
	Polimorfismo
	Interface
	Declarando uma interface
	Classes abstratasem linguagem Java de maneira geral. 
Nossa estratégia aqui será criar pequenos projetos e explorar e 
aprofundar os conhecimentos básicos da sintaxe da linguagem 
um pouco em cada um deles. Vamos, então, para o nosso primeiro 
projeto!
O primeiro projeto Java
Para este primeiro projeto, abra o Eclipse (IDE Integrated 
Development Environment), ou seja, “Ambiente de Desenvolvimento 
Integrado”, e crie o seguinte workspace: c:\java\Projeto_01, como 
mostrado na imagem a seguir.
11PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.1 – Definição do workspace do primeiro projeto Java
Fonte: Elaborada pela autoria (2023).
IMPORTANTE
O espaço de trabalho (workspace) é o local 
(diretório) em que serão gravados todos os 
arquivos necessários para que seu projeto funcione 
adequadamente.
Logo que você clicar no botão Launch, o espaço de trabalho 
será criado na pasta “c:\java\Projeto_01”, e o IDE Eclipse será 
aberto, exatamente como mostrado na imagem a seguir. Repare 
que do lado esquerdo do IDE está o Package Explorer (marcado com 
o número 1), cuja função é apresentar lista de classes, bibliotecas e 
demais arquivos (resources) que serão necessários no seu projeto. 
O centro da IDE (marcado com o número 2) é o espaço em que o 
código em linguagem Java será digitado.
12 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.2 – IDE Eclipse
Fonte: Elaborada pela autoria (2023).
Em seguida, clique em menu File -> New -> Project, e o 
assistente vai criar um novo projeto que será apresentado, como 
mostra a imagem a seguir.
Imagem 2.3 – Criando projeto Java
Fonte: Elaborada pela autoria (2023).
13PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Selecione a opção Java Project, como mostrado na imagem 
anterior e clique Next. Uma nova tela será apresentada.
Imagem 2.4 – Nomeando o projeto
Fonte: Elaborada pela autoria (2023).
Em sequência, digite um nome para o seu projeto – “Exe1” 
– e clique em Finish. A parte da IDE relativa ao Package Explorer 
deve ficar como mostra a imagem a seguir.
Imagem 2.5 – Package Explorer no projeto Exe1
Fonte: Elaborada pela autoria (2023).
14 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Note que seu projeto Exe1 foi criado e tem duas subpastas:
 • A pasta “src” é o local onde serão incluídas as classes 
desenvolvidas para o seu projeto. O termo “src” é a 
abreviação da palavra source, que significa “fonte”, isto 
é, dentro dessa pasta serão gravadas as classes (código-
fonte) do seu projeto.
 • Dentro da pasta “JRE System Library” estão as bibliotecas 
de classes que, como descrito anteriormente, permitem 
que sua máquina rode o código Java no sistema 
operacional escolhido. Como você pode reparar, a 
pasta “src” está vazia, ou seja, seu projeto também o 
está. Nosso próximo passo é criar a primeira classe 
desse projeto.
A primeira classe Java
Agora siga os seguintes passos:
 • Clique no menu File -> New -> Package, para criar o 
primeiro pacote (pasta) onde vamos inserir a primeira 
classe no seu projeto. Digite: “exercicio1” para o nome 
do pacote, como mostra a imagem a seguir:
15PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.6 – Criando o primeiro pacote para o projeto
Fonte: Elaborada pela autoria (2023).
Clique em Finish, e seu projeto deve ficar como o mostrado 
na sequência:
Imagem 2.7 – Novo pacote criado
Fonte: Elaborada pela autoria (2023).
16 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Dentro do pacote “exercicio1”, ficarão as classes que 
iremos criar. Então, vamos criar nossa primeira classe, finalmente.
 • Clique no menu File -> New -> Class, para criar a primeira 
classe do nosso projeto, como mostra a imagem a 
seguir.
Imagem 2.8 – Criando a primeira classe
Fonte: Elaborada pela autoria (2023).
17PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Note que o Pacote (Package) já está definido como 
“exercicio1”, pois é dentro dele que a classe será criada. Agora siga 
os seguintes passos:
 • • Digite o nome para a classe: “Principal”;
 • • Marque a opção: “public static void main(String[] args), 
como mostrado na imagem anterior;
 • • Deixe o restante como está e clique Finish.
A classe “Principal” será criada dentro do pacote “exercicio1” 
e o Eclipse deve mostrar algo parecido com a imagem a seguir:
Imagem 2.9 – Primeira classe criada
Fonte: Elaborada pela autoria (2023).
Observe na imagem anterior (imagem 2.9) o Package 
Explorer, no qual podemos visualizar a classe “Principal.java” 
dentro do pacote “exercicio1”, que está localizado na pasta “src” 
do projeto “Exe1”, conforme definido anteriormente. No centro, 
veremos o conteúdo da classe “Principal.java”, que será utilizada 
para inserir o código necessário para o nosso primeiro projeto em 
Java. A imagem a seguir fornece detalhes sobre o conteúdo da 
classe “Principal.java”, para uma análise mais aprofundada.
18 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.10 – Classe “Principal.Java”
Fonte: Elaborada pela autoria (2023).
A linha 1 define que a classe “Principal.java” está dentro 
do pacote “exercicio1”. A linha 3 inicia a declaração da classe 
“Principal.java”. O termo public define que a classe “Principal.java” é 
pública. Classes, atributos e métodos podem ser declarados como 
public, protected ou private. Veremos mais detalhes sobre esses 
modificadores de acesso nas próximas páginas deste material.
IMPORTANTE
Uma classe deve sempre iniciar com abre chaves 
“{” e finalizar com fecha chaves “}”. Mais detalhes 
sobre as classes em Java serão vistos nas próximas 
páginas deste material.
Nas linhas 5 a 9, um bloco de comentário é apresentado. 
Sempre que for necessário fazer um comentário em bloco sobre 
o código, deve-se utilizar o comando “/*” para iniciar o bloco de 
comentário e “*/” para finalizá-lo. Digite seu nome e a data de 
hoje dentro do bloco de comentário. É boa prática descrever 
qual a função da classe que está a ser implementada. Alguns 
programadores iniciantes concluem que inserir comentários 
dentro do código Java é perda de tempo, porém programadores 
19PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
profissionais utilizam esse recurso, que facilita a leitura do código, 
em caso de alteração ou atualização, principalmente quando se 
precisa alterar ou corrigir algo que foi feito por outro programador.
Nas linhas 10 a 13 está declarado o método main, especial 
da classe. Ele sempre será o primeiro método a ser executado 
num programa Java, isto é, serve como ponto de partida para 
a execução do projeto. Da mesma forma que as classes, cada 
método declarado deve sempre iniciar com abre chaves “{“ e será 
finalizado com fecha chaves “}”.
Note que não existe nenhum código dentro dele, apenas 
um comentário em linha. Os comentários em linha sempre são 
iniciados com o comando “//”; Dessa forma, digite o seguinte 
código dentro do método main:
Imagem 2.11 – Primeiro código em Java
Fonte: Elaborada pela autoria (2023).
20 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Na imagem anterior (imagem 2.11), o comando: “System.
out.println(...);” é responsável por mostrar o texto que está entre 
parênteses. Nesse caso: “Meu primeiro código Java”, no console 
do IDE.
Para executar o programa Java, clique no botão Run, 
mostrado na imagem 2.11. O programa Java deve ser compilado, 
gerando bytecodes e interpretado pela JVM, gerando o resultado 
no Console, como mostrado na sequência (imagem 2.12).
Imagem 2.12 – Resultado da execução do primeiro projeto Java
Fonte: Elaborada pela autoria (2023).
Se você conseguiu o mesmo resultado que foi apresentado 
na imagem anterior, parabéns! O primeiro passo está dado! Até o 
momento não estamos trabalhando com um projeto JavaAndroid, 
mas com um projeto Java simples (desktop), pois o objetivo desta 
unidade é apresentar a linguagem Java para que você possa 
implementar projetos em dispositivos móveis.
IMPORTANTE
A Linguagem Java diferencia letras maiúsculas de 
letras minúsculas. Preste atenção em como você 
declara e usa as variáveis em seu programa, assim 
evita perdertempo.
Estrutura básica da linguagem 
Java
A linguagem de programação Java é concorrente, baseada 
em classes, orientada a objetos e de propósito geral (Mattos, 2007, 
21PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
p. 30). Dessa definição, podem-se relacionar alguns conceitos 
importantes, relacionados no quadro a seguir.
Quadro 2.1 – Estrutura básica da linguagem Java
Item Descrição
Programação 
Concorrente
Programação que permite fazer uso 
simultâneo (concorrente) de várias 
tarefas computacionais.
Programação 
Baseada em 
Classes
Programação que tem como base os 
protótipos (classes) identificados num 
determinado cenário.
Programação 
Orientada a 
Objetos
Programação que utiliza as 
potencialidades da orientação 
a objetos, tais como herança, 
polimorfismo, encapsulamento, entre 
outros.
Linguagem 
de Propósito 
Geral
Linguagem que pode ser utilizada 
para implementar uma solução para 
qualquer cenário.
Fonte: Elaborado pela autoria com base em Mattos (2007).
Estrutura de um programa Java
Para o desenvolvimento dos exercícios deste material, 
será adotada a seguinte estrutura para um programa Java básico:
 • Projeto – todo programa Java deve fazer parte de um 
projeto;
 • Pacote – cada projeto deve ter um ou mais pacotes. 
Cada pacote (Package) serve para organizar/separar as 
classes com funções semelhantes.
 • Classes – cada pacote deve ter uma ou mais classes.
 • Variáveis – cada classe pode ter uma ou mais variáveis.
 • Atributos – cada classe pode ter um ou mais atributos.
22 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
 • Métodos – cada classe pode ter um ou mais métodos. 
Para reforçar o entendimento do que foi exposto até o 
momento, vamos treinar.
Siga os seguintes passos:
 • Abra o Projeto Exe1, criado no item anterior.
 • Crie outro pacote, chamado: “exercicio2”.
 • Dentro deste novo pacote, crie uma classe “Principal”, 
contendo o método main.
 • Na Classe Principal, insira um comentário com o seu 
nome e a data de hoje.
 • Dentro do método main, digite um código para mostrar 
no console a seguinte frase: “Inicio do Exercicio2”.
Seguindo os mesmos passos apresentados no item 
anterior, a tela do Eclipse deve ficar como mostrado na imagem 
a seguir:
23PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.13 – Exemplo: implementando a Classe Java
Fonte: Elaborada pela autoria (2023).
Identificadores
Dentro de um programa existem variáveis, constantes, 
classes, objetos, dentre outros elementos. Para cada um desses 
elementos é necessário definir um nome. Este é chamado de 
identificador.
Imagem 2.14 – Exemplo de identificador
int x;
x = 0;
Fonte: Elaborada pela autoria (2023).
24 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
No código apresentado foi definida uma variável de nome 
“x”, que recebe o valor 0 (zero). Então, para esse caso, “x” é o 
identificador de uma variável do tipo int (inteiro). Para definir o 
nome de identificadores é necessário seguir algumas regras:
 • Acentuação deve ser evitada;
 • Letras maiúsculas são diferenciadas de letras 
minúsculas;
 • Não pode haver espaços em branco;
 • Deve-se iniciar com uma letra ou caractere “_”;
 • Pode conter número a partir do segundo caractere;
 • Não pode conter caracteres de pontuação ou especiais, 
tais como: “#”, “@”, “&”, “?”, “!”, “:” etc.;
 • Não pode ser uma palavra reservada (Veja no item 
1.2.4).
O quadro a seguir exemplifica identificadores válidos e 
inválidos.
Quadro 2.2 – Exemplos de identificadores válidos e inválidos
Identificadores Válidos Identificadores Inválidos
Num_Cliente Num Cliente
Cliente !Cliente
A10 10A
Funcionario float
Fonte: Elaborado pela autoria (2023).
No quadro anterior, float é uma palavra reservada da 
linguagem Java para identificar um tipo de dado.
25PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Palavras reservadas
As palavras reservadas são utilizadas pelo sistema como 
palavras-chave e não podem ser utilizadas como identificadores.
Quadro 2.3 – Exemplos de palavras reservadas
abstract Default if private this
boolean Do implements protected throw
break Double import public throws
byte Else instanceof return transient
case Extends int short try
goto continue new for Const
while Switch native float Class
catch Final interface Static void
char Finally long super volatile
package synchronized strictfp
Fonte: Elaborado pela autoria (2023).
Não precisa decorar essas palavras reservadas. Durante 
o aprendizado, você perceberá quando uma delas aparecer. Mas 
em seu programa nunca utilize qualquer uma dessas palavras 
para dar nome a variáveis, classes, objetos ou qualquer elemento 
definido pelo usuário.
IMPORTANTE
Todas as palavras são escritas em letras minúsculas.
Variáveis
Quando um programa é desenvolvido, normalmente 
deve atender a uma ou mais necessidades do mundo real e, para 
tanto, precisa modelar essa realidade o mais possível próximo da 
26 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
exatidão. Assim, para que o programa modele apropriadamente 
a realidade, seus elementos (variáveis, métodos, classes, objetos 
etc.) devem estar definidos com o tipo adequado de dado.
Imagine que exista a necessidade de montar um programa 
para somar dois números. Uma análise rápida permite perceber 
que é necessário definir três variáveis: uma para o primeiro 
número, outra para o segundo número e uma terceira variável 
para armazenar a soma dos dois primeiros números. Então, no 
programa Java, devem ser definidas três variáveis, mas estas 
precisam ter seus tipos também definidos para que o programa 
se assemelhe ao máximo da realidade em questão.
Essas variáveis não podem ser do tipo texto, pois este não 
pode ser somado. Também não podem ser do tipo inteiro, porque, 
com certeza, em algum momento será necessário somar números 
com casas decimais. Então, essas variáveis devem ser definidas 
como números reais, isto é, que podem armazenar números 
positivos e negativos e com casas decimais, se necessário.
A imagem a seguir mostra o segmento de código para 
executar a soma em questão.
Imagem 2.15 – Bloco de código para somar dois números
float x;
float y;
float z;
x = 10; y = 2;
z = x + y;
Fonte: Elaborada pela autoria (2023).
Como mostra o exemplo anterior, cada variável definida 
num programa Java será armazenada num local da memória e 
deverá estar associada a um tipo de dado, para seu correto uso. A 
27PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
linguagem Java permite a definição de dois tipos básicos de dados 
para as variáveis, quais sejam: simples e composto. Vamos a eles.
Tipos de dados simples
São dados que não podem ser divididos em tipos primitivos.
Quadro 2.4 – Tipos de dados simples
 • INTEIROS
Nome Descrição Tamanho
byte Armazena valores entre -128 e +127 08 bits
short
Armazena valores entre -32.768 e 
+32.767
16 bits
int
Armazena valores entre -2.147.483.648 e 
+2.147.483.647
32 bits
long
Armazena valores entre 
-9.223.372.036.854.775.808 e 
+9.223.372.036.854.775.807
64 bits
 • PONTO FLUTUANTE
Nome Descrição Tamanho
float
Armazena valores com precisão de 6 
dígitos depois da vírgula.
32 bits
double
Armazena valores com precisão de 14 
dígitos depois da vírgula
64 bits
 • BOOLEANO
Nome Descrição Tamanho
bool Armazena os valores lógicos true e false
 • CARACTERE
Nome Descrição Tamanho
char Armazena um único caractere 16 bits
Fonte: Elaborado pela autoria (2023).
Para se definir uma variável com um tipo de dados simples, 
use a seguinte sintaxe: .
28 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.16 – Declaração de valoração de variáveis de tipos de dados simples
int var1;
var1 = 3;
double Valor;
Valor = 10.34;
boolean Retorno;
Retorno = false;
char Sexo;
Sexo = ‘M’;
Fonte: Elaborada pela autoria (2023).
Veja a seguir como definir mais de uma variável do mesmo 
tipo.
Imagem 2.17 – Declaração de variáveis do mesmo tipo
int var1, var2, var3;
var1 = 3;
var2 = 1;
var3 = 2;
//ou
int var4;
int var5;
int var6;var4 = 5;
var5 = 6;
var6 = 4;
Fonte: Elaborada pela autoria (2023).
Pode-se também definir um valor inicial para a variável 
quando ela é declarada, veja o exemplo:
29PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.18 – Declaração e valoração de variáveis
int var8 = 10;
//ou
int var9;
var9 = 10;
Fonte: Elaborada pela autoria (2023).
Imagine que precisamos desenvolver um programa que 
faça a soma de dois números inteiros e apresente o resultado no 
console. Para resolver essa questão, devemos seguir os seguintes 
passos:
 • Para o projeto Exe1, no pacote exercicio2;
 • Dentro do método “main”, defina três variáveis do tipo 
inteiro, com os seguintes nomes: Num1, Num2 e Result;
 • Atribua valores inteiros às variáveis Num1 e Num2 e 
realize a operação de soma das duas, armazenando o 
resultado na variável “Result”;
 • Mostre o seguinte resultado no console: “O resultado 
da soma é: ...”. No lugar dos três pontos, deve estar o 
valor armazenado em “Result”.
Imagem 2.19 – Exemplo de código para somar dois números inteiros
Fonte: Elaborada pela autoria (2023).
30 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Melhorando o código: com a ajuda de comentários, pode-
se facilitar a compreensão do código anterior, da seguinte maneira:
Imagem 2.20 – Exemplo de código com comentários
Fonte: Elaborada pela autoria (2023).
Agora, salve o projeto e execute-o. O resultado apresentado 
no console deve ser o seguinte.
Imagem 2.21 – Resultado da execução de código
Fonte: Elaborada pela autoria (2023).
É importante notar que a atividade faz apenas a soma de 
números inteiros. Caso seja colocado um valor não inteiro para 
algumas das variáveis, um erro será gerado, mostrando que o tipo 
de variável definido (int) não suporta um valor que não seja inteiro.
Tipos de dados compostos
Dados compostos são aqueles que não estão entre os oito 
tipos primitivos (simples) de dados. Todos os tipos compostos são 
31PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
classes. As variáveis do tipo composto podem armazenar um dos 
seguintes valores:
 • Uma referência nula: “null”;
 • Uma referência para qualquer objeto cuja classe seja 
compatível com o tipo da variável.
Armazenar uma referência para qualquer objeto significa 
que a variável não armazena o valor que é atribuído a ela, mas é um 
“ponteiro” que aponta para o endereço onde está aquela instância 
de classe (objeto). É este endereço que tem o valor desejado.
 “String” e “Arrays” são os tipos de dados compostos mais 
comuns. Os objetos definidos pelo usuário também são do 
tipo referência. Veremos esses conceitos com mais detalhes no 
decorrer deste material.
Conversão de tipos
Durante o desenvolvimento do programa, pode haver a 
necessidade de trocar (mudar) o tipo de dado de uma variável 
para outro tipo. Essa troca é chamada de “conversão de tipos” ou 
“casting”, em inglês, e tem a seguinte sintaxe:
Imagem 2.22 – Sintaxe casting
() 
ou
() 
Fonte: Elaborada pela autoria (2023).
Nesse exemplo, a variável “x” é do tipo inteiro e tem o 
valor 10 como conteúdo. Declara-se, então, uma variável “b”, do 
tipo byte, e faz-se uma conversão de tipo (casting) para atribuir o 
conteúdo da variável “x” para a variável “b”.
32 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.23 – Sintaxe casting 2
int x = 10;
byte b;
b = (byte) x;
Fonte: Elaborada pela autoria (2023).
Exemplo utilizando expressão:
Imagem 2.24 – Sintaxe casting 3
int x, y;
x = 10; y = 6;
byte b;
b = (byte) x + y;
Fonte: Elaborada pela autoria (2023).
Algumas conversões podem causar perda de informação. 
Isso acontece quando se quer, por exemplo, converter uma 
variável do tipo double para int, como é mostrado a seguir:
Imagem 2.25 – Sintaxe casting 4
double PI = 3.141642;
int i;
i = (int) PI
Fonte: Elaborada pela autoria (2023).
Imagine o seguinte cenário: precisamos montar um bloco 
de código que declare uma variável do tipo double com valor igual 
a 12,34 e outra variável do tipo int. Por um motivo qualquer, é 
necessário fazer a atribuição do valor da variável do tipo double para 
a variável do tipo int, usando conversão de tipos, sendo necessário 
apresentar o resultado no console. Para resolver esse problema, 
crie um novo pacote no projeto Exe1, chamado de exercicio3 e, 
33PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
dentro dele, crie uma nova classe chamada “Conversão de tipos”. 
Não se esqueça de que a classe precisa conter o método main. O 
código segue o exemplo mostrado na imagem a seguir.
Imagem 2.26 – Exemplo de conversão de tipos
Fonte: Elaborada pela autoria (2023).
Repare que o valor 12,34 poderia ser definido como float, e 
não como double, porém o Java não aceita a atribuição de valores 
do tipo float em variáveis. Pesquise por que isso acontece.
Salve a classe e execute-a. O resultado apresentado deve 
ser o número “12”. Perceba que a conversão de tipo double para 
int teve como consequência a perda de informação!
34 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Escopo de variável
Segundo o Dicionário Priberam de Língua Portuguesa, 
“escopo” significa o “limite ou abrangência de uma operação” 
(Escopo, on-line, 2024). Sendo assim, quando se trata de escopo 
de variáveis em um código Java, é necessário perceber que 
uma variável pode não ser válida em todo o programa, mas, 
sim, apenas dentro de uma classe ou método, ou, ainda, que a 
variável pode ser válida apenas dentro de um bloco de código 
dentro de um método. É importante destacar também que uma 
variável declarada em Java deve estar numa das três categorias 
apresentadas no quadro a seguir.
Quadro 2.5 – Categorias das variáveis
Categoria Descrição
Atributo
Quando a variável é declarada como atributo de uma 
classe. Também são chamadas de variáveis de instância. 
O conteúdo de um atributo é válido (escopo) apenas 
dentro daquela instância de classe;
Local
Quando a variável é declarada dentro de um método 
ou dentro de um bloco de código definido dentro de 
um método. O conteúdo de uma variável Local é válido 
(escopo) dentro do método ou dentro do bloco de 
código ao qual pertence;
De Classe
Quando a variável tem seu valor associado à própria 
classe, isto é, seu valor é considerado (escopo) em 
todas as instâncias daquela classe. As variáveis de 
classe são definidas utilizando a palavra-chave static;
Fonte: Elaborado pela autoria (2023).
O código a seguir mostra a declaração de variáveis nas 
categorias apresentadas na imagem anterior.
35PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.27 – Exemplo de declaração de categorias de variáveis
Fonte: Elaborada pela autoria (2023).
Modificadores de acesso
No que diz respeito às variáveis declaradas como (categoria) 
“atributo”, em geral, podem ser definidas como atributos públicos 
(public), privados (private) ou protegidos (protected). Um atributo 
declarado como público pode ser acessado diretamente por outras 
classes que instanciarem aquela que tem esse tipo de atributo. 
Isso não ocorre no caso de atributos privados, que não ficam 
acessíveis. Por sua vez, os que são declarados como protegidos só 
podem ser acessados por subclasses e/ou classes que estejam no 
mesmo pacote.
Atributos públicos
Atributos do tipo public podem ser acessados por todas as 
classes. Para verificar essa afirmação, crie um novo pacote, dentro 
do projeto Exe1, chamado de exercicio4. Dentro desse pacote, crie 
uma classe chamada Mod_Publico (que não deve conter o método 
main). O código deve ser como o apresentado na imagem a seguir:
36 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.28 – Exemplo de classe com atributo do tipo público
Fonte: Elaborada pela autoria (2023).
Crie no mesmo pacote uma outra classe, chamada 
“Principal” (que deve conter o método main). O código deve ser o 
mostrado na imagem a seguir.
Imagem 2.29 – Exemplo de acesso com atributo do tipo público
Fonte: Elaborada pela autoria (2023).
37PROGRAMAÇÃO CODING (MOBILE)
Uni
da
de
 2
Repare que, no exemplo anterior, o atributo da classe 
Mod_publico pode ser acessado diretamente, bastando para isso 
instanciar a classe.
Atributos privados
Atributos do tipo “private” não pode ser acessado 
diretamente por todas as classes. Para verificar essa afirmação, 
siga os seguintes passos:
1. Dentro do pacote exercicio4, crie uma classe chamada 
Mod_Privado (que não deve conter o método “main”). 
O código deve ser como o apresentado na imagem a 
seguir.
Imagem 2.30 – Exemplo de classe com atributo do tipo privado
Fonte: Elaborada pela autoria (2023).
2. Na classe “Principal”, criada no exemplo anterior, 
modifique o código para que fique como mostrado na 
imagem a seguir:
38 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.31 – Exemplo de acesso ao tributo do tipo público e ao privado
Fonte: Elaborada pela autoria (2023).
IMPORTANTE
No exemplo anterior, não foi possível acessar o 
atributo do tipo privado. Para fazê-lo, é necessário 
utilizar os métodos getters e setters.
 • Getters: métodos que permitem capturar os valores dos 
atributos privados. 
 • Setters: métodos que permitem definir os valores para 
os atributos privados.
39PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Neste exemplo, vamos criar uma nova classe que tenha 
atributos do tipo privado, mas que também tenham métodos 
getters e setters. Sendo assim, no mesmo pacote, crie uma classe 
chamada “Mod_Privado2”, com o seguinte conteúdo:
Imagem 2.32 – Classes com atributos privados e métodos getters e setters
Fonte: Elaborada pela autoria (2023).
Modifique o conteúdo da classe principal, para ficar como 
mostrado na imagem a seguir.
40 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.33 – Exemplo de acesso ao atributo do tipo privado com métodos getters e setters
Fonte: Elaborada pela autoria (2023).
41PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Operadores
A linguagem Java disponibiliza seis tipos de operadores. 
Neste tópico, vamos apresentar, descrever e verificar como utilizar 
cada um deles.
Operadores aritméticos
Quadro 2.6 – Operadores aritméticos
Operador Descrição
+ Soma
- Subtração
* Multiplicação
/ Divisão
 Fonte: Elaborado pela autoria (2023).
A regra de precedência dos operadores aritméticos 
obedece à regra (de precedência) definida pela matemática básica, 
com relação a operações aritméticas.
Operadores de atribuição
Para a tabela a seguir, considere que a variável x tenha 
sido declarada com valor inicial igual a 12.
Tabela 2.1 – Operadores de atribuição
Operador
Exemplo de 
Código
Explicação da 
Operação
Valor final de x 
= x = 4; x = 4; 4
+= x += 4; x = x + 4; 16
–= x –= 4; x = x - 4; 8
*= x *= 4; x = x * 4; 48
/= x /= 4; x = x / 4; 3
%= x %= 4; x = x % 4; 0
Fonte: Elaborada pela autoria (2023).
42 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Crie um novo pacote no projeto Exe1, chamado de 
exercicio5, dentro do qual crie uma nova classe clamada 
Operadores1 (que deve conter o método main. Dentro do método 
main, siga as seguintes instruções (sem utilizar operadores de 
atribuição):
1. Declare uma variável do tipo inteiro;
2. Atribua o valor 10 a essa variável;
3. Some 3 e armazene o resultado nela mesma;
4. Subtraia 1 e armazene o resultado nela mesma;
5. Divida por 2 e armazene o resultado nela mesma;
6. Multiplique por 7 e armazene o resultado nela mesma;
7. Mostre o resultado no console.
Caso você tenha seguido exatamente como informado, 
seu código deve estar igual ao mostrado na imagem a seguir.
Imagem 2.34 – Exemplo de código usando operadores aritméticos
Fonte: Elaborada pela autoria (2023).
43PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
O valor apresentado no console deve ser: 42. Crie uma 
nova classe chamada Operadores2 que realize os mesmos passos 
do exemplo anterior. Desta vez, porém, utilize apenas operadores 
de atribuição. Seu código deve ficar assim:
Imagem 2.35 – Exemplo de código com uso de operadores de atribuição
Fonte: Elaborada pela autoria (2023).
O valor apresentado no console deve ser: 42.
Operadores de incremento e decremento
Para a tabela a seguir, considere que a variável “x” tenha 
sido declarada com o valor inicial igual a 2 e a variável “y”, com 
valor inicial igual a 0.
44 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Tabela 2.2 – Operadores de incremento e decremento
Operador
Exemplo de 
Código
Explicação da 
Operação
Valor final de x 
e y 
Pré-incremento 
++
y = ++x;
Primeiro incrementa 
e depois atribui.
x = 3
y = 3
Pós-incremento
++
y = x++;
Primeiro atribui e 
depois incrementa.
x = 3 
y = 2
Pré-decremento 
--
y = --x;
Primeiro decrementa 
e depois atribui.
x = 1 
y = 1
Pós-decremento
--
y = x--;
Primeiro atribui e 
depois decrementa.
x = 1 
y = 2
Fonte: Elaborada pela autoria (2023).
Crie uma nova classe, chamada Operadores3, e siga os 
seguintes passos.
1. Declare duas variáveis (a e b) do tipo inteiro;
2. Atribua o valor 10 para a variável a e 0 para a variável b;
3. Mostre o valor das duas variáveis no console;
4. Faça um pré-incremento na variável b e atribua o valor 
de b em a;
5. Mostre o valor das duas variáveis no console;
6. Faça um pós-decremento na variável b e atribua o valor 
de b em a;
7. Mostre o valor das duas variáveis no console.
Seu código deve ficar assim:
45PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.36 – Exemplo de uso de operadores de incremento e decremento
Fonte: Elaborada pela autoria (2023).
Operadores relacionais
Para a tabela a seguir, considere que as variáveis “x” 
e “y” foram declaradas com valores iniciais iguais a 13 e 5, 
respectivamente.
Tabela 2.3 – Operadores relacionais
Operador Discrição Exemplo Resultado
== Igual (x == y) Falso
!= Diferente (x != Y) Verdadeiro
 Maior que (x > Y) Verdadeiro
= Maior ou igual a (x >= Y) Verdadeiro
Fonte: Elaborada pela autoria (2023).
Operadores booleanos
Para a tabela a seguir, considere que as variáveis “x” 
e “y” foram declaradas com valores iniciais iguais a 13 e 5, 
respectivamente.
46 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Tabela 2.4 – Operadores booleanos
Operador Discrição Exemplo Resultado
&& E (x == 13) && (y > 5) Falso
|| OU (x == 13) || (y > 5) Verdadeiro
! Não !(y = ?:;
Fonte: Elaborada pela autoria (2023).
Imagine o seguinte bloco de código:
Imagem 2.38 – Exemplo de bloco
int num1 = 11;
 int num2 = 12;
 int num3;
num1 = (num1 > num2)?num1:num2;
Fonte: Elaborada pela autoria (2023).
Se o resultado da condição “(num1>num2)” for verdadeiro, 
a variável num3 recebe o valor de num1; caso contrário, num3 
recebe o valor de num2.
47PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
RESUMINDO
E então? Gostou do que lhe mostramos? Aprendeu 
mesmo tudinho? Agora, só para termos certeza de 
que você realmente entendeu o tema de estudo 
deste capítulo, vamos resumir tudo o que vimos. 
Neste subtítulo, você aprendeu sobre o Java Básico. 
Aqui, você viu sobre o Primeiro Projeto Java, sobre 
a Primeira Classe Java, bem como sobre a Estrutura 
básica da linguagem Java.
48 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Estrutura de controle de 
seleção
OBJETIVO
Ao término deste capítulo, você será capaz de 
entender como funciona a sintaxe básica da 
estrutura de controle de seleção da linguagem 
Java. E então? Motivado para desenvolver esta 
competência? Então vamos lá. Avante!
Comando if
O controle de seleção if (que significa “se”) permite ao 
programador definir se um bloco de código será ou não executado, 
dependendo do resultado de um teste, que pode ser verdadeiro 
ou falso. Caso seja verdadeiro, o bloco de código é executado; 
caso contrário, não será executado.
Imagem 2.39– Sintaxe if
if (teste)
{
 Bloco de Código;
}
 Fonte: Elaborada pela autoria (2023).
O teste é uma condição booleana, isto é, qualquer 
expressão que retorne como resultado os valores “true” ou “false”.
Imagem 2.40 – Resultado if
 
int idade = 15;
if (idade )
{
case valor1:
bloco de código que deve ser executado se a variável tiver valor 
= valor1;
break;
case valor2:
bloco de código que deve ser executado se a variável tiver valor 
= valor1;
break;
case valorN:
bloco de código que deve ser executado se a variável tiver valor 
= valorN;
break;
default:
bloco de código que deve se a variável não encontrar nenhuma 
correspondência nos cases acima;
break;
}
 Fonte: Elaborada pela autoria (2023).
IMPORTANTE
Os cases não podem testar valores booleanos, por 
isso, a linguagem Java não vai conseguir entender 
o que deve ser deito caso seja digitada a seguinte 
linha de comando: “case valor1 >10”.
53PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.44 – Exemplo case valor1 > 10
int i = 3;
swicth (i)
{
case 1:
 System.out.println(“i é igual a 1”);
 break;
case 2:
 System.out.println(“i é igual a 2”);
 break;
default:
 System.out.println(“i é diferente de 1 e diferente de 2”);
 break;
}
 Fonte: Elaborada pela autoria (2023).
Estrutura de controle de 
repetição
While
O comando while (que significa “enquanto”) permite que 
um bloco de código seja repetido um número definido de vezes 
durante a execução do programa. Para controlar quantas vezes o 
bloco de código deve ser repetido, utiliza-se uma condição (teste). 
Por definição, enquanto o resultado do teste for verdadeiro, o 
bloco de código deve ter sua execução repetida. A sintaxe para o 
comando while é a seguinte:
54 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.45 – Sintaxe while
While (condição)
{
 Bloco de código que deve ser executado enquanto a condição for 
verdadeira.
}
EXEMPLO
int idade = 15;
while (idade2.47 – Incremento
for (int i = 0; i 50 && i 
{
 Bloco de código que deve ser executado quando este método foi 
chamado.
}
Fonte: Elaborada pela autoria (2023).
Onde:
 • O termo public define que o método pode ser acessado 
por outras classes que instanciarem a classe que 
contém esse método. Se desejar tornar esse método 
inacessível para outras classes, é necessário substituir 
o termo public por private.
 • O tipo de retorno informa ao programa que tipo de dado 
o método vai retornar quando for executado. Pode-se 
utilizar qualquer um dos tipos primitivos ou compostos 
(também chamados de tipos de referência). Caso o 
método não precise ter retorno, utiliza-se o termo void. 
Se o método tiver algum tipo de retorno, a última linha 
a ser executada é o comando return acompanhado da 
variável que armazena o valor a ser retornado.
 • Para o nome do método, utiliza-se qualquer 
identificador válido que ainda não tenha sido utilizado 
para declarar outros elementos nessa mesma classe. O 
nome do método deve sempre ser seguido por abre e 
fecha parênteses “()”, caso não tenha parâmetros. Caso 
contrário, os parâmetros devem ser declarados entre 
os parênteses.
62 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Para este exemplo, crie um novo pacote, chamado de 
exercicio6. Dentro dele, crie uma classe chamada de Principal (que 
deve conter o método main). O conteúdo dessa classe deve ser o 
seguinte:
Imagem 2.51 – Exemplo de chamada de método
Fonte: Elaborada pela autoria (2023).
Explicando o exemplo citado:
1. Quando o programa é executado, o primeiro método 
a ser chamado quando é o método main (linha 12), 
conforme já dito anteriormente neste material.
2. Dentro do método main, três variáveis são declaradas 
(linhas 13 a 15) e têm seus tipos e valores definido. São 
elas: a, b e c.
63PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
3. Na linha 16 existe uma chamada ao método soma, 
passando como parâmetros as variáveis a e b.
4. A execução do programa passa para a linha 5, em que o 
método soma (que foi chamado na linha 16) recebe os 
dois parâmetros, “X” e “Y”. Isso quer dizer que apenas 
dentro do método soma() a variável “a” será chamada 
de “X” e a variável “b”, de “Y”.
5. O método soma() executa a operação de adição das 
suas duas variáveis e armazena o resultado na variável 
“resultado” (linhas 8). A última linha do método soma 
(linha 9) faz o retorno da soma das variáveis (return 
resultado).
6. A execução do programa retorna para a linha 16, na 
qual o resultado da soma é atribuído à variável c, dentro 
do método main.
7. Na linha seguinte (linha 17), o programa executa 
um comando para mostrar no console o resultado 
calculado pelo método soma. Como segundo exemplo 
de chamada de método, implemente nos métodos 
subtração, multiplicação e divisão para as mesmas 
variáveis a e b e teste o resultado do programa. Seu 
código deve ficar assim:
64 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.52 – Exemplo 2 de estrutura de métodos
Fonte: Elaborada pela autoria (2023).
Classes
Como foi verificado anteriormente neste material, a 
Programação Java é baseada em classes. Isso quer dizer que toda 
65PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
a estrutura da programação Java está baseada no envio e no 
recebimento de mensagens entre as classes, ou seja, uma classe 
chama a outra por meio de métodos. Para melhor entendimento 
do que seja uma classe e de como podemos criá-las utilizando a 
linguagem Java, imagine a classe CALCULADORA especificada na 
imagem.
Imagem 2.53 – Calculadora
Calculadora
double resultado
double Soma(double X,double Y)
double Subtr(double X, double Y)
double Multipl(double X, double Y)
double Divisao(double X, double Y)
 Fonte: Elaborada pela autoria (2023).
Repare que essa classe tem apenas um atributo, chamado 
“resultado”, e tem quatro métodos, um para cada operação 
matemática básica. Para implementar essa classe, siga os 
seguintes passos:
1. Crie um novo pacote (package), chamado “Calculadora”, 
e uma classe principal (com o método main) dentro 
dele. A imagem a seguir mostra como deve ficar o 
Package Explorer do seu projeto.
Imagem 2.54 – Pacote calculadora
Fonte: Elaborada pela autoria (2023).
66 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Não apague os outros pacotes (exercicio1 e exercicio2), 
pois é muito interessante que você tenha um histórico da sua 
evolução em programação Java, mas nosso foco agora será o 
Pacote Calculadora.
2. Agora, crie uma nova classe, chamada “calc”, dentro do 
pacote Calculadora. Mas nesta classe NÃO marque a 
opção: “public static void main(String[] args)”. O Package 
Explorer deve ficar assim:
Imagem 2.55 – Pacote calculadora com duas classes
Fonte: Elaborada pela autoria (2023).
3. Clique duas vezes sobre a classe principal.java e o 
“Eclipse” exibirá a seguinte tela:
Imagem 2.56 – Pacote Principal Java – com o método main
Fonte: Elaborada pela autoria (2023).
67PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Repare que essa classe tem o método “public static void 
main(String[ ] args)”. Como você deve ter percebido, o nome do 
método é simplesmente “main” e tem como atributo o array do 
tipo String, chamado “args”.
4. Clique duas vezes sobre a classe calc.java e o Eclipse 
deve mostrar a seguinte tela:
Imagem 2.57 – Classe Calc – sem o método MAIN
Fonte: Elaborada pela autoria (2023).
Repare que a classe “Calc” não deve ter o método main, 
o qual só deve estar presente na classe principal do pacote. Para 
implementar o exemplo, nosso trabalho consiste em traduzir 
o “desenho” representado na classe calculadora para dentro do 
código Java – classe “Calc”.
Imagem 2.58 – Classe calculadora
Calculadora
double resultado
double Soma(double X, double Y)
double Subtr(double X, double Y)
double Multipl(double X, double Y)
double Divisao(double X, double Y)
 
Fonte: Elaborada pela autoria (2023).
Vamos demonstrar passo a passo a implementação da 
classe calculadora:
68 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
1. Acrescente um bloco de comentário padrão e declare o 
atributo na classe “calc”:
Imagem 2.59 – Exemplo parte I
Fonte: Elaborada pela autoria (2023).
2. Acrescente os métodos descritos na imagem a seguir 
na classe “calc”.
69PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.60 – Exemplo – Parte II
Fonte: Elaborada pela autoria (2023).
Note que o código apresentado deve apresentar quatro 
indicações de erros. Para identificar o motivo da indicação de erro, 
pare o ponteiro do mouse sobre cada um dos erros e verifique os 
respectivos motivos. O erro deve ser como mostrado na imagem 
a seguir.
70 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.61 – Identificação do erro de código
Fonte: Elaborada pela autoria (2023).
Note que o problema está no fato de que nós escrevemos 
um método que deveria retornar uma variável do tipo double, 
e não escrevemos a linha de código para que esse retorno seja 
feito. Dessa forma, a própria IDE apresenta opções para corrigir o 
problema: podemos adicionar o comando return ou mudar o tipo 
de retorno do método para void. Para nosso caso, a solução mais 
adequada é inserir o comando return. O nosso código fica, então, 
como mostrado na imagem a seguir:
Imagem 2.62 – Código corrigido
Fonte: Elaborada pela autoria (2023).
71PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
A partir de agora, o que falta é apenas inserir as 
funcionalidades para cada método.
IMPORTANTE
Para o método divisão(), é preciso verificar primeiro 
se o denominador é diferente de zero, a fim de 
evitar erro do programa em tempo de execução, 
pois, como você deve saber, não existe resultado 
para a divisão por zero.
Imagem 2.63 – Métodos implementados na Classe Calc
Fonte: Elaborada pela autoria (2023).
72 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Neste ponto do exemplo, o código da classe “calc” já 
está pronto, pois o atributo e os métodos já estão corretamente 
declarados e implementados. Resta agora implementar a classe 
main, para que esta instancie a classe “Calc” e faça a chamada dos 
métodos (envie as mensagens para a classe). Para que a classe 
main envie uma mensagem, chamando o método soma() da classe 
“calc”, a classe main deve primeiro instanciar a classe “calc”, como 
mostrado na imagem a seguir:
Imagem 2.64 – Classe principal a instanciar a Classe Calc
Fonte: Elaborada pela autoria (2023).
Note que, para se instanciar uma classe, isto é, criar um 
objeto, deve-se usar a seguinte notação: = new (); Onde.
 • Tem a mesma função que o utilizado nos tópicos 
anteriores, neste material;
 • É o nome que o programador dará para o objeto que 
está sendo criado;
 • É uma palavra reservada que informa ao programa que 
o programador está criando uma nova instância de 
uma classe;
73PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
 • É o nome que o programador deu para a classe que ele 
está querendo instanciar. Sempre deve ser seguido de 
abre e fecha parênteses “()”. Para o caso em estudo, a 
linha de código que instancia a classe “calc” é a seguinte: 
Calc C = new Calc().
A partir dessa linha, o programa entende que existe um 
objeto chamado “C” que foi instanciado a partir da classe “Calc”. 
Em seguida, utilizamos o objeto “C” para chamar os métodos da 
classe à qual ele faz referência. Execute o programa e você verá 
que o resultado da soma será apresentado no console. Agora, 
siga os mesmos procedimentos apresentados para o processo 
de soma de duas variáveis e implemente os códigos para que o 
método main da classe principal execute subtração, multiplicação 
e divisão.
Imagine que precisamos criar um novo método, chamado 
“média()”, na classe “calc”, para calcular a média entre dois 
números inteiros. Lembre-se de que esse método deve receber 
dois parâmetros do tipo especificado. O código deve ficar mais ou 
menos assim:
Imagem 2.65 – Método média()
Fonte: Elaborada pela autoria (2023).
Agora, faça uma chamada ao método “media()”, a partir do 
método main da classe principal.
74 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.66 – Inserindo a chamada ao método Média() na classe main
Fonte: Elaborada pela autoria (2023).
RESUMINDO
E então? Gostou do que lhe mostramos? Aprendeu 
mesmo tudinho? Agora, só para termos certeza de 
que você realmente entendeu o tema de estudo 
desse tópico, vamos resumir tudo o que vimos. 
Aqui, você aprendeu sobre a classe Java. Além 
disso, você viu uma parte da introdução sobre 
o tema, seus métodos, bem como suas classes. 
Esperamos que você tenha gostado do conteúdo 
apresentado.
75PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Polimorfismo, interface e 
classes abstratas
OBJETIVO
Ao término desse capítulo, você será capaz de 
entender como funcionam o polimorfismo, a 
interface e as classes abertas na linguagem 
de programação Java. E então? Motivado para 
desenvolver esta competência? Então vamos lá. 
Avante!
Polimorfismo
O polimorfismo ocorre quando o programa é implementado 
de maneira que “o mesmo método” pode responder de diferentes 
formas. Trata-se da capacidade da implementação de operações 
de maneira diferente da definida originalmente na classe base. 
Dall’Oglio (2016) destaca ainda que:
O significado da palavra polimorfismo nos 
remete a “muitas formas”. Polimorfismo 
em orientação a objetos é o princípio que 
permite que classes derivadas de uma 
mesma superclasse tenham métodos iguais 
(com a mesma nomenclatura e os mesmos 
parâmetros), mas comportamentos diferentes, 
redefinidos em cada uma das classes-filhas. 
(Dall’oglio, 2016)
Seguindo essa ideia, usaremos aqui o mesmo exemplo 
que trabalhamos comPHP. Isso permite a você perceber as 
similaridades e as diferenças entre as duas linguagens de 
programação para tratar este conceito. Imagine o cenário 
representado pelo diagrama abaixo.
76 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.67 – Representação gráfica da herança de duas classes
Conta
Agencia
Conta
Saldo
Registrar_Conta(Ag, Cta, S)
Depositar(Valor)
Sacar(Valor)
 
Conta_Poupanca
Sacar(Valor)
Fonte: Elaborada pela autoria (2023).
Primeiro, vamos implementar a classe Conta. Para 
implementar essa classe, crie um novo pacote no projeto Exe01, 
chamado exercicio7. Dentro desse pacote, crie uma classe Conta 
sem o método main, declare os atributos e implemente os 
métodos, de acordo com a imagem a seguir. O seu código deve 
ficar mais ou menos assim:
77PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.68 – Classe Conta
Fonte: Elaborada pela autoria (2023).
Agora que temos a classe Conta, crie uma nova, no mesmo 
pacote “exercicio7”, chamado “ContaPoupança”. Esta deve ser uma 
subclasse da classe Conta. Ser uma subclasse significa herdar as 
características e comportamentos da classe-mãe (ou superclasse).
78 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
IMPORTANTE
Herança é a propriedade que permite que 
uma classe (filha ou subclasse) herde atributos 
(características) e métodos (comportamentos) de 
outra classe (mãe ou superclasse).
Conforme podemos verificar, a subclasse “ContaPoupança” 
deve conter um método “sacar” com a mesma assinatura (mesmo 
nome e argumentos) que a classe-mãe (Conta). Para usar a 
herança, em Java, utiliza-se a palavra reservada extends. A classe 
(filha) “ContaPoupança” deve ficar mais ou menos assim:
Imagem 2.69 – Conta Poupança
Fonte: Elaborada pela autoria (2023).
Para o conteúdo do método sacar da classe 
“ContaPoupança”, podemos imaginar que o valor não pode ser 
maior do que o saldo da conta, verificação que não acontece na 
classe Conta. Então, nosso código fica mais ou menos assim:
79PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.70 – Classe Conta Poupança
Fonte: Elaborada pela autoria (2023).
Note que essa classe “ContaPoupança” herda (extends) 
da classe “Conta”, criada anteriormente. Repare também que a 
classe-filha “contaPoupanca” tem um método com o mesmo nome 
(método sacar()) que a classe-mãe “conta”, mas o conteúdo do 
método sacar na classe-mãe é diferente do conteúdo do método 
sacar na classe-filha.
Para testar o funcionamento das classes “conta” e 
“contaPoupanca”, crie uma nova classe no mesmo pacote 
“exercicio7” com o nome de Principal (que deve ter o método 
main) com o seguinte código:
80 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.71 – Classe Principal
Fonte: Elaborada pela autoria (2023).
Note que o método Sacar(Valor), apresentado na imagem 
anterior, verifica se a quantia a ser sacada é maior que o valor 
do saldo da conta. A resposta apresentada no console deve ser a 
seguinte:
Imagem 2.72 – Resultado da execução do código
Fonte: Elaborada pela autoria (2023).
81PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Interface
Uma interface é um tipo composto (ou referência) em 
Java e pode ser considerada uma classe com métodos abstratos. 
Alguns tutoriais Java, como o site TutorialPoint, consideram que 
escrever uma interface é similar a escrever uma classe. No entanto, 
uma classe deve descrever os atributos e os comportamentos 
de um objeto, e a interface, por sua vez, contém a descrição dos 
comportamentos que uma classe deve implementar.
A lista a seguir apresenta algumas características de uma 
interface que não podem ser esquecidas quando queremos utilizá-
las adequadamente:
 • Uma interface não pode ser instanciada;
 • Uma classe não pode herdar (extends) as características 
ou os comportamentos de uma interface, mas pode 
implementá-las (implement);
 • Todos os métodos de uma interface devem ser 
abstratos;
 • Uma interface não pode conter atributos instanciáveis;
 • Uma interface pode herdar (extends) de outra interface.
Declarando uma interface
Para declarar uma interface, devemos utilizar a palavra-
chave “interface”. Imagine que, no exemplo que utilizamos para 
a classe Conta, quiséssemos fazer algumas modificações, como: 
fazer com que a Classe Conta não mais contivesse qualquer 
código, mas apenas a declaração dos métodos (comportamentos) 
necessários para todos os tipos de contas que nela estivessem 
baseadas. Nossa Classe Conta ficaria assim:
82 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.73 – Interface Conta
Fonte: Elaborada pela autoria (2023).
Essa interface Conta foi criada num novo pacote, chamado 
exercicio8, no mesmo projeto exe01. Se criarmos uma classe que 
implemente (implements) a interface Conta, deve ser assim:
Imagem 2.74 – Classe ContaCorrente
Fonte: Elaborada pela autoria (2023).
Repare que, ao lado da marcação da linha3, existe um “x” a 
indicar que ali existe um erro. De pararmos o ponteiro do mouse 
sobre o “x”, teremos a seguinte informação:
Imagem 2.75 – Classe ContaCorrente
Fonte: Elaborada pela autoria (2023).
83PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Note que a IDE informa a você que, para que a classe 
ContaCorrente seja executada sem erros, deve implementar os 
métodos da classe Conta. Legal, não é?! Isso permite que você crie 
uma espécie de “contrato” para exigir que os programadores que, 
porventura, queiram implementar a interface que você criou para 
um determinado negócio, devam implementar determinados 
métodos obrigatórios para o correto funcionamento.
Classes abstratas
Assim como o PHP, a linguagem Java também permite o 
recurso de utilizar classes estruturais para servir de base para a 
criação de outras classes mais especializadas.
IMPORTANTE
Uma classe abstrata não pode ser instanciada 
diretamente; apenas servir de base para criação 
de novas classes (Dall’oglio, 2016). Para definir 
uma classe abstrata em Java, utiliza-se a palavra 
reservada abstract antes da definição da classe 
em si.
Diferentemente do que acontece com a interface, uma classe 
qualquer pode herdar as características e os comportamentos da 
classe abstrata. Contudo, da mesma forma que acontece com a 
interface, a classe abstrata pode conter métodos abstratos com 
o intuito de assegurar que as suas classes-filhas implementem 
todos os métodos necessários para seu correto funcionamento.
Como visto no tópico relativo às interfaces, os métodos 
abstratos têm a função de servir de molde para os métodos 
da classe-filha (extends) da classe abstrata ou (para o caso das 
interfaces) de servir de molde para as classes que a implementam 
(implements). Imagine que você queira transformar a interface 
Conta numa classe abstrata. Crie um novo pacote, chamado 
exercicio9 e, dentro dele, crie uma classe, sem o método main. 
84 PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Antes de apertar o botão Finish, selecione a opção “abstract”, como 
mostrado na imagem a seguir:
Imagem 2.76 – Criando uma classe abstrata
Fonte: Elaborada pela autoria (2023).
Dentro da classe Conta, insira o seguinte conteúdo:
85PROGRAMAÇÃO CODING (MOBILE)
U
ni
da
de
 2
Imagem 2.77 – Classe abstrata
Fonte: Elaborada pela autoria (2023).
Note que apenas dois métodos são abstratos, o que 
significa que a classe abstrata conta pode ter a superclasse de 
uma classe ContaCorrente, por exemplo. Esta subclasse poderá 
herdar (extends) dos atributos e métodos já implementados na 
classe Conta e deverá obrigatoriamente implementar o conteúdo 
dos métodos abstratos “Depositar” e “Sacar”.
Fizemos uma longa caminhada e esperamos que este 
material tenha ajudado você a entender os conceitos básicos da 
programação em linguagem Java. É claro que existe muito mais a ser 
estudado, caso você queira se tornar um expert em programação 
Java, mas nosso intuito aqui não foi esgotar o assunto, e, sim, 
apresentar o que pensamos serem os conceitos fundamentais.