Programação - Coding Mobile (Java) - 2

Prévia do material em texto

Unidade II
Fundamentos da Linguagem 
Java para Android
Introdução ao 
Coding Mobile
Diretor Executivo 
DAVID LIRA STEPHEN BARROS
Gerente Editorial 
CRISTIANE SILVEIRA CESAR DE OLIVEIRA
Projeto Gráfico 
TIAGO DA ROCHA
Autoria 
LUIZ FERNANDO CORCINI
AUTORIA
Luiz Fernando Corcini
Olá. Meu nome é Luiz Fernando Corcini. Sou formado 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. 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!
ICONOGRÁFICOS
Olá. Esses ícones irão aparecer em sua trilha de aprendizagem toda vez 
que:
OBJETIVO:
para o início do 
desenvolvimento 
de uma nova 
competência;
DEFINIÇÃO:
houver necessidade 
de apresentar um 
novo conceito;
NOTA:
quando necessárias 
observações ou 
complementações 
para o seu 
conhecimento;
IMPORTANTE:
as observações 
escritas tiveram que 
ser priorizadas para 
você;
EXPLICANDO 
MELHOR: 
algo precisa ser 
melhor explicado ou 
detalhado;
VOCÊ SABIA?
curiosidades e 
indagações lúdicas 
sobre o tema em 
estudo, se forem 
necessárias;
SAIBA MAIS: 
textos, referências 
bibliográficas 
e links para 
aprofundamento do 
seu conhecimento;
REFLITA:
se houver a 
necessidade de 
chamar a atenção 
sobre algo a ser 
refletido ou discutido;
ACESSE: 
se for preciso acessar 
um ou mais sites 
para fazer download, 
assistir vídeos, ler 
textos, ouvir podcast;
RESUMINDO:
quando for preciso 
fazer um resumo 
acumulativo das 
últimas abordagens;
ATIVIDADES: 
quando alguma 
atividade de 
autoaprendizagem 
for aplicada;
TESTANDO:
quando uma 
competência for 
concluída e questões 
forem explicadas;
SUMÁRIO
Java Básico .................................................................................................... 12
O Primeiro Projeto Java ............................................................................................................... 12
A Primeira Classe Java ............................................................................................. 15
Estrutura Básica da Linguagem Java .............................................................................. 20
Introdução ........................................................................................................................ 20
Estrutura de um Programa Java ........................................................................ 21
Identificadores ................................................................................................................22
Palavras Reservadas ..................................................................................................23
Variáveis ..............................................................................................................................24
Tipos de Dados Simples .........................................................................................25
Tipos de Dados Compostos .................................................................................28
Conversão de Tipos ................................................................................28
Escopo de Variável ..................................................................................................... 30
Modificadores de Acesso ....................................................................................... 31
Atributos Públicos ....................................................................................32
Atributos Privados ....................................................................................32
Operadores .......................................................................................................................35
Operadores Aritméticos .......................................................................35
Operadores de Atribuição ..................................................................35
Operadores de Incremento e Decremento ...........................37
Operadores Relacionais ......................................................................................... 38
Operadores Booleanos ........................................................................................... 38
Operador Ternário .................................................................................... 39
Estrutura de Controle de Seleção e de Repetição .......................40
Estrutura de Controle de Seleção ..................................................................................... 40
Comando if ....................................................................................................................... 40
Comando if – else ........................................................................................................ 41
Condições mais elaboradas ..............................................................42
O comando swicth ......................................................................................................43
Estrutura de Controle de Repetição..................................................................................45
while.......................................................................................................................................45
for .............................................................................................................................................47
Controlando Loops .................................................................................................... 48
O comando break .................................................................................... 48
O comando continue ............................................................................. 49
Classes em Java ...........................................................................................50
Introdução ............................................................................................................................................ 50
Métodos ................................................................................................................................................ 50
Classes ....................................................................................................................................................53
Polimormismo, Interface e Classes Abstratas ................................62
Polimorfismo .......................................................................................................................................62
Interface ................................................................................................................................................ 65
Declarando uma Interface ....................................................................................66
Classes Abstratas ........................................................................................................................... 67
9
UNIDADE
02
Introdução ao Coding Mobile
10
INTRODUÇÃO
Seja bem-vindo (a) à Unidade 2 – Fundamentos da Linguagem Java 
para Android - da disciplina de Introdução ao Coding (Mobile). Nesta 
unidade trataremos os conceitos fundamentais de programação Java 
necessários para que você possa desenvolver aplicativos nesta linguagem. 
É de se referir que, apesar do foco da disciplina ser programação para 
dispositivosmóveis, os conceitos apresentados nesta unidade serão 
úteis mesmo para programação Java em qualquer ambiente. O conteúdo 
desta Unidade está dividido em quatro módulos. No primeiro módulo 
apresentamos a sintaxe das instruções básicas do Java para manipulação 
de variáveis e outros recursos elementares da linguagem. No módulo 2 
estudaremos as estruturas de controle e repetição de fluxo. No módulo 
3 aprenderemos como trabalhar com classes em Java e, finalmente, 
no módulo 4, trabalharemos conceitos fundamentais da programação 
orientada à objeto, como polimorfismo, classes abstratas e interfaces.
É claro que existe muito mais a aprender, mas o aprofundamento 
de cada um destes conhecimentos pode ser feito acessando os links 
indicados durante o texto, no tópico [Saiba Mais]. Vamos começar? 
Excelente estudo para você!
 
Introdução ao Coding Mobile
11
OBJETIVOS
Olá. Seja muito bem-vindo a nossa Fundamentos da Linguagem 
Java para Android, e o nosso objetivo é auxiliar você no desenvolvimento 
das seguintes competências profissionais até o término desta etapa de 
estudos:
1. Conhecer a sintaxe das instruções básicas do Java para manipulação 
de variáveis e outros recursos elementares da linguagem;
2. Entender 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. Compreender e aplicar os conceitos de polimorfismo, classes 
abstratas e interfaces na linguagem Java.
Vamos, então, rumo ao conhecimento. Bons estudos!
Introdução ao Coding Mobile
12
Java Básico
Neste primeiro módulo aprenderemos a sintaxe básica da 
linguagem de programação Java. 
RESUMINDO:
No primeiro módulo instalamos e configuramos todos 
os recursos necessários para permitir criar, em seu 
computador, o ambiente necessário para desenvolver 
projetos em Java.
Apesar do foco desta disciplina ser programação para dispositivos 
móveis, o conteúdo apresentado nesta unidade serve como base para 
programação em 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 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 figura abaixo.
Figura 1 – Definição do ‘Workspace’ do primeiro projeto Java.
Fonte: Autor
Introdução ao Coding Mobile
13
RESUMINDO:
O espaço de trabalho (workspace) é o local (diretório) onde 
será gravado todos os arquivos necessários para que o 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 figura 2 (abaixo).
Repare que do lado esquerdo do IDE está o “Package Explorer” 
(marcado com o número 1) cuja função é apresentar a lista de classes, 
bibliotecas e demais arquivos (resources) que serão necessários no seu 
projeto. No centro da IDE (marcado com o número 2) é o local onde o 
código em linguagem Java será digitado.
Figura 2 – IDE Eclipse
Fonte: Autor
Clique no menu File -> New -> Project e o assistente irá criar um 
novo projeto e será apresentado, como mostra a figura 3:
Introdução ao Coding Mobile
14
Figura 3 – Criando novo Projeto Java
Fonte: Autor
Selecione a opção “Java Project”, como mostrado acima (Figura 3) e 
clique NEXT. Uma nova tela (figura 4) será apresentada.
Figura 4 – Nomeando o projeto
Fonte: Autor
Introdução ao Coding Mobile
15
Digite o nome para o seu projeto: “Exe1” e clique em FINISH. A parte 
da Ide relativa ao Package Explorer deve ficar como mostra a figura abaixo.
Figura 5 – Package Explorer do projeto Exe1
Fonte: Autor
Note que o seu projeto Exe1 foi criado e possui duas subpastas:
 • A pasta “src” é 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 desta 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 a sua 
máquina rode código Java, no sistema operacional escolhido.
Como você pode reparar, a pasta “src” está vazia, ou seja, seu projeto 
está vazio. Nosso próximo passo é criar a primeira classe deste projeto.
A Primeira Classe Java
Agora siga os seguintes passos:
 • Clique no menu File -> New -> Package, para criar o primeiro pacote (pasta) 
onde iremos inserir a primeira classe no seu projeto. Digite: “exercicio1” 
para o nome do pacote, como mostra a figura abaixo (Figura 6):
Figura 6 – Criando o primeiro pacote para o projeto
Fonte: Autor
Introdução ao Coding Mobile
16
 ...Clique FINISH e seu projeto deve ficar como o mostrado na figura 
abaixo (Figura 7):
Figura 7 – Novo pacote criado.
Fonte: Autor
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 figura abaixo (Figura 8):
Figura 8 – Criando a primeira classe
Fonte: Autor
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 figura acima;
Introdução ao Coding Mobile
17
 • 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 figura abaixo (Figura 9):
Figura 9 – Primeira classe criada.
Fonte: Autor
Note, na figura acima (Figura 9), que o Package Explorer, onde 
vemos a classe: “Principal.java”, dentro do pacote “exercicio1”, que está 
dentro da pasta “src” do projeto “Exe1”, como definido acima.
Ao centro vemos o conteúdo da classe “principal.java”. Esta classe 
será usada para digitar o código necessário para o nosso primeiro projeto 
em Java. A figura abaixo (Figura 10) mostra em detalhes, o conteúdo da 
classePrincipal.java”, para detalhamento.
Figura 10 – Classe Principal.java
Fonte: Autor
Introdução ao Coding Mobile
18
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 estes modificadores de acesso mais nas 
próximas páginas, neste 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 neste material.
Nas linhas 5 a 9 é apresentado um bloco de comentário. 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 
profissionais utilizam este recurso, pois ele facilita a leitura do código, e 
em caso de alteração ou atualização, principalmente quando o código 
que se precisa alterar ou corrigir foi feito por outro programador. 
Nas linhas 10 a 13 está declarado o método “main”. Este é um 
método especial da classe. Ele sempre será o primeiro método que será 
executadonum programa Java, isto é, ele 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 “//”;
Introdução ao Coding Mobile
19
Digite o seguinte código dentro do método main:
Figura 11 – primeiro código em Java.
Fonte: Autor
Na figura acima (Figura 11), o comando: “System.out.println(...); ” é 
responsável por mostrar o texto que está entre parênteses. Neste caso: 
“Meu primeiro código Java”, no console do IDE;
Para executar o programa Java clique no botão “Run”, mostrado na 
“Figura 11”.
O programa Java deve ser compilado, gerando “bytecodes” e 
interpretado pela JVM, gerando o resultado no Console, como mostrado 
na figura abaixo (Figura 12):
Figura 12 – Resultado da execução do primeiro projeto java.
Fonte: Autor
Se você conseguiu o mesmo resultado que foi apresentado na 
figura acima, parabéns! O primeiro passo está dado! 
Até o momento não estamos trabalhando com um projeto Java-
Android, mas sim com um projeto Java simples (desktop), pois o objetivo 
desta Unidade 2 é apresentar a linguagem Java, para que você possa 
implementar projetos em dispositivos móveis na próxima unidade.
Introdução ao Coding Mobile
20
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 perder tempo.
Estrutura Básica da Linguagem Java
Introdução
A linguagem de programação Java é concorrente, baseada 
em classes, orientada a objetos e de propósito geral. 
(MATTOS, 2007, p. 30).
Dessa definição, podem-se relacionar alguns conceitos importantes, 
relacionados na tabela a seguir.
Tabela 1 – Conceitos básicos 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) identifi cados num determinado cenário.
Programação 
Orientada a 
Objetos
Programação que utiliza as potencialidades 
da orientação a objetos, tais como herança, 
polimorfi smo, encapsulamento, entre outros
Linguagem 
de Propósito 
Geral
Linguagem que pode ser utilizada para 
implementar uma solução para qualquer cenário.
Introdução ao Coding Mobile
21
Estrutura de um Programa Java
Para o desenvolvimento dos exercícios desse 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;
 • 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 figura abaixo (Figura 13):
Introdução ao Coding Mobile
22
Figura 13 – Exemplo – Implementando a Classe Java
 
Fonte: Autor
Identificadores
Dentro de um programa existem variáveis, constantes, classes, 
objetos entre outros elementos. Para cada um desses elementos é 
necessário definir um nome. Este é chamado de identificador.
Exemplo: 
int x;
x = 0;
No código acima foi definida uma variável de nome “x”, que recebe 
o valor 0 (zero). Então, para este caso, “x” é o identificador de uma variável 
do tipo int (inteiro).
Para definir o nome de identificadores é necessário seguir algumas regras:
 • Evite utilizar acentuação;
 • Letras maiúsculas são diferenciadas de letras minúsculas;
Introdução ao Coding Mobile
23
 • Não pode conter espaços em branco;
 • Deve 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).
A tabela abaixo exemplifica identificadores válidos e inválidos.
Tabela 2 – Exemplos de Identificadores válidos e inválidos
Identificadores Válidos Identificadores Inválidos
Num_Cliente Num Cliente
Cliente !Cliente
A10 10A
Funcionario fl oat
Na tabela acima, “float” é uma palavra reservada da linguagem Java 
para identificar um tipo de dado.
Palavras Reservadas
As palavras Reservadas são utilizadas pelo sistema como palavras 
chave e não podem ser utilizadas como identificadores. São elas:
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 fl oat Class
catch Final interface Static void
char Finally long super volatile
package synchronized strictfp
Você não precisa decorar estas palavras reservadas. Durante o 
aprendizado você perceberá quando uma delas aparecer. Mas, nunca 
Introdução ao Coding Mobile
24
utilize nenhuma dessas palavras para dar nome a variáveis, classes, 
objetos ou qualquer elemento definido pelo usuário em seu programa.
Obs: Todas são escritas em letras minúsculas. 
Variáveis
Quando um programa é desenvolvido, normalmente ele deve 
atender a uma ou mais necessidades do mundo real e para tanto ele 
precisa modelar esta realidade o mais próximo da exatidão possível. 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.
Exemplo: Imagine que existe 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, elas precisam ter seus tipos também definidos, para 
que o programa se assemelhe o máximo da realidade em questão. Estas 
variáveis não podem ser do tipo texto, pois não se pode somar textos. 
Também não podem ser do tipo inteiro, pois, 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 figura abaixo (Figura 14) mostra o segmento de código 
para executar a soma em questão.
Figura 14 – bloco de código para somar dois números.
Fonte: Autor
Como mostra o exemplo acima, 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 linguagem Java 
Introdução ao Coding Mobile
25
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. São eles:
 • 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.808e 
+9.223.372.036.854.775.807
64 bits
 • PONTO FLUTUANTE
Nome Descrição Tamanho
fl oat 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 Valores
bool Armazena os valores lógicos true e false
 • CARACTERE
Nome Descrição Tamanho
char Armazena um único caractere 16 bits
Introdução ao Coding Mobile
26
Para se definir uma variável com um tipo de dados simples use a 
seguinte sintaxe:
<nome do tipo> <nome da variável>;
Figura 15 – Declaração de valoração de variáveis de tipos de dados simples.
Fonte: Autor
Pode-se definir mais de uma variável do mesmo tipo, da seguinte maneira:
Figura 16 – Declaração de variáveis do mesmo tipo.
Fonte: Autor
Pode-se também definir um valor inicial para a variável no momento 
em que ela é declarada, por exemplo:
Figura 17 – Declaração e valoração de variáveis.
Fonte: Autor
Imagine que precisamos desenvolver um programa que faça a 
soma de dois números inteiros e apresente o resultado no console. Para 
resolver esta questão, devemos seguir os seguintes passos:
Introdução ao Coding Mobile
27
 • 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 as 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.
Figura 18 – Exemplo de código para somar dois números inteiros.
Fonte: Autor
Melhorando o código: Com a ajuda de comentários, pode-se facilitar 
a compreensão do código acima, da seguinte maneira:
Figura 19 – O mesmo código da figura 18 com a inserção de comentários.
Fonte: Autor
Repare como fica muito mais fácil de ler o código na figura 19, do que 
na figura 18. Agora, salve o projeto e execute-o. O resultado apresentado 
no console deve ser o seguinte:
Introdução ao Coding Mobile
28
Figura 20 – resultado da execução do código da figura 19.
Fonte: Autor
É importante notar que a atividade acima 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 tipos de dados que não estejam entre 
os oito tipos primitivos (simples) de dados. Todos os tipos compostos 
são 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) 
e este endereço possui o valor desejado. Os tipos “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 estes conceitos com mais detalhes no decorrer deste material.
Conversão de Tipos
Durante o desenvolvimento do programa pode haver necessidade 
de trocar (mudar) o tipo de dado de uma variável para outro tipo. Esta 
troca é chamada de “conversão de tipos” ou “casting”, em inglês, e tem a 
seguinte sintaxe:
Introdução ao Coding Mobile
29
(<tipo final>) <identificador>
ou
(<tipo final>) <expressão>
Neste exemplo, a variável “x” é do tipo inteiro e possui como 
conteúdo o valor 10. 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”.
int x = 10;
byte b;
b = (byte) x;
Exemplo utilizando expressão:
int x, y;
x = 10; y = 6;
byte b;
b = (byte) x + y;
Algumas conversões podem causar perda de informação. Isto 
acontece quando se quer, por exemplo, converter uma variável do tipo 
“double” para “int”, como mostrado abaixo:
double PI = 3.141642;
int i;
i = (int) PI;
Imagine este 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 e é necessário apresentar o resultado no console. Para 
resolver este problema, crie um novo pacote no projeto Exe1, chamado 
de exercicio3 e, dentro deste pacote, crie uma nova classe chamada 
Introdução ao Coding Mobile
30
Conversao_de_tipos. Não esqueça que a classe precisa conter o método 
“main”. O código seria mais ou menos assim:
Figura 21 – Exemplo de conversão de tipos
Fonte: Autor
Repare que o valor 12,34 poderia ser definido como “float” e não 
como “double”, porem 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! 
Escopo de Variável
Segundo o dicionário Priberiam1, “escopo” significa o “limite ou 
abrangência de uma operação”. 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 de 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 na tabela abaixo:
Introdução ao Coding Mobile
31
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 defi nido 
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 defi nidas utilizando a palavra-chave static;
O código abaixo mostra a declaração de variáveis nas categorias 
apresentadas na tabela 4.
Figura 22 – Exemplo de declaração de categorias de variáveis.
Fonte: Autor
Modificadores de Acesso
Relativamente às variáveis que são declaradas como (categoria) Atributo: 
De maneira geral, podem ser definidas como atributos públicos 
(public), atributos privados (private) ou atributos protegidos (protected). 
Um atributo declarado como público pode ser acessado diretamente 
por outras classes que instanciarem a classe que possui este tipo de 
atributo. Isto não ocorre para o caso de atributos privados, que não ficam 
acessíveis. Já os atributos declarados como protegidos só poderão ser 
acessados por sub-classes e/ou classes que estejam no mesmo pacote.
Introdução ao Coding Mobile
32
Atributos Públicos
Atributos do tipo “public” podem ser acessados por todas as classes.
Para verificar esta afirmação, crie um novo pacote, dentro do projeto 
Exe1, chamado de exercicio4. Dentro deste 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 figura abaixo:
Figura 23 – Exemplo de Classe com atributo do tipo público.
Fonte: Autor
Crie no mesmo pacote uma outra classe, chamada “Principal” ( que 
deve conter o método “main”). O código deve ser o mostrado na figura 
abaixo:
Figura 24 - Exemplo de acessoà atributo do tipo público
Fonte: Autor
Repare que no exemplo acima 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. 
Introdução ao Coding Mobile
33
Para verificar esta 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 figura 
abaixo:
Figura 25 – Exemplo de Classe com atributo do tipo privado.
Fonte: Autor
(2) Na classe “Principal”, criada no exemplo anterior, modifique o 
código para que fique como mostrado na figura a seguir:
Figura 26 - Exemplo de acesso à atributo do tipo público e outro privado.
Fonte: Autor
IMPORTANTE:
No exemplo acima, não foi possível acessar o atributo do 
tipo privado. Para acessar este tipo de atributo é necessário 
utilizar os métodos “getters” e “setters”.
 • Getters: métodos que permitem capturar os valores dos atributos 
privados;
Introdução ao Coding Mobile
34
 • Setters: métodos que permitem definir os valores para os atributos 
privados.
Neste exemplo vamos criar uma nova classe que possua atributos 
do tipo privado, mas que também possuam metodos “getters” e “setters.” 
Sendo assim, no mesmo pacote, crie uma nova classe, chamada de 
“Mod_Privado2”, com o seguinte conteúdo:
Figura 27 – Classes com atributos privados e métodos getters e setters.
Fonte: Autor
Modifique o conteúdo da classe principal, para ficar como mostrado 
na figura abaixo (Figura28):
Figura 28 - Exemplo de acesso à atributo do tipo privado com métodos getters e setters
Fonte: Autor
Introdução ao Coding Mobile
35
Operadores
A linguagem Java disponibiliza seis tipos de operadores. Neste tópico 
iremos apresentar, descrever e verificar como utilizar cada um deles.
Operadores Aritméticos
Operador Descrição
+ Soma
- Subtração
* Multiplicação
/ Divisão
A regra de precedência dos operadores aritméticos obedece a 
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 abaixo, considere que a variável x tenha sido declarada 
com valor inicial igual a 12.
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
Crie um novo pacote no projeto Exe1, chamado de exercicio5. 
Dentro deste pacote, criar uma nova classe clamada Operadores1 (que 
deve conter o método “main”). Dentro do método “main”, siga as seguintes 
Introdução ao Coding Mobile
36
instruções (sem utilizar operadores de atribuição): (1) Declare uma variável 
do tipo inteiro; (2) Atribua o valor 10 a esta 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 acima, o seu 
código deve estar igual ao mostrado na figura abaixo:
Figura 29 – Exemplo de código com uso de operadores aritméticos
Fonte: Autor
O valor apresentado no console deve ser: 42.
Crie uma nova classe, chamada Operadores2 que realize os 
mesmos passos que o exemplo anterior, só que desta vez, a utilizar 
apenas operadores de atribuição. Seu código deve ficar assim:
Figura 30 – Exemplo de código com uso de operadores de atribuição.
Fonte: Autor
Introdução ao Coding Mobile
37
O valor apresentado no console deve ser: 42.
Operadores de Incremento e Decremento
Para a tabela abaixo, considere que a variável “x” tenha sido 
declarada com o valor inicial igual a 2 e a variável “y” tenha sido declarada 
com valor inicial igual a 0.
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 x += 4; x = x + 4; 16
Pós-
incremento
x –= 4; x = x – 4; 8
++ y = x++; Primeiro atribui 
e depois 
incrementa.
x = 3 
y = 2 x /= 4; x = x / 4; 3
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
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:
Introdução ao Coding Mobile
38
Figura 31 – Exemplo de uso de operadores de incremento e decremento.
Fonte: Autor
Operadores Relacionais
Para a tabela abaixo considere que as variáveis “x” e “y” foram 
declaradas com valores iniciais iguais a 13 e 5, respectivamente.
Operador Descrição Exemplo Resultado
== Igual (x == y) Falso
!= Diferente (x != y) Verdadeiro
< Menor que (x < y) Falso
> Maior que (x > y) Verdadeiro
<= Menor ou igual a (x <= y) Falso
>= Maior ou igual a (x >= y) Verdadeiro
Operadores Booleanos
Para a tabela abaixo considere que as variáveis “x” e “y” foram 
declaradas com valores iniciais iguais a 13 e 5, respectivamente.
Operador Descrição Exemplo Resultado
&& E (x == 13) && (y 
> 5)
Falso
|| OU (x == 13) || (y > 5) Verdadeiro
! Não !(y > 5) Verdadeiro
Introdução ao Coding Mobile
39
Operador Ternário
O operador ternário tem as mesmas características do comando if-
else (que veremos mais adiante). Sua sintaxe é a seguinte:
<variável> = <condição>?<caso true>:<caso false>;
Imagine o seguinte bloco de código:
int num1 = 11;
 int num2 = 12;
 int num3;
num1 = (num1 > num2)?num1:num2;
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.
Introdução ao Coding Mobile
40
Estrutura de Controle de Seleção e de Repetição
INTRODUÇÃO:
Toda linguagem de programação precisa ter sua estrutura 
de controle, que permite ao programador desenvolver e 
controlar como o programa deve responder a determinadas 
condições, quando em execução.
Estrutura de Controle de Seleção
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, cujo resultado pode ser verdadeiro ou falso. Caso 
o resultado do teste seja verdadeiro, o bloco de código é executado, caso 
contrário, o bloco de código não será executado.
A sintaxe do “if” é a seguinte:
if (teste)
{
 Bloco de Código;
}
O teste é uma condição Booleana: isto é, qualquer expressão que 
retorne como resultado os valores “true” ou “false”.
int idade = 15;
if (idade <18)
{
 System.out.println(“Não pode entrar”);
}
Introdução ao Coding Mobile
41
No exemplo acima, o teste é (idade < 18). A linha de código “if (idade 
< 18)” deve ser lida da seguinte maneira: “Se o valor da variável ‘idade’ 
for menor que 18”. Caso o resultado deste teste seja verdadeiro, isto é, 
“true”, o bloco de código logo abaixo do teste deve ser executado. Para 
o caso do exemplo acima, se o valor da variável idade for menor que 18, 
o programa deve mostrar no console a seguinte mensagem: “Não pode 
entrar”. O bloco de código que deve ser executado está limitado pelo abre 
chaves “{“ e pelo fecha chaves “}”.
Comando if – else
Como foi visto no item anterior, o comando “if” permite que um 
bloco de código seja executado se a condição apresentada no teste for 
verdadeira. Porém, algumas vezes é necessário definir o queo programa 
deve fazer caso o resultado da condição apresentada no teste for falsa. 
Para estes casos, utiliza-se o comando “else” (que significa SENÃO). 
O comando “else” nunca pode ser utilizado sozinho, mas sempre como 
complemento do comando “if”. A sintaxe para o comando “if-else” é a seguinte:
if (condição)
{
Bloco de código – deve ser executado se a condição for 
verdadeira.
}
else
{
 Bloco de código – deve ser executado se a condição for falsa.
}
Introdução ao Coding Mobile
42
EXEMPLO
int idade = 15;
if (idade <18)
{
 System.out.println(“Não pode entrar”);
}
else
{
 System.out.println(“Pode entrar”);
}
Como pode ser observado no exemplo acima, o programa pode 
apresentar dois tipos de mensagens. Caso a condição resultante do teste 
(idade < 18) seja verdadeira (true), o programa vai apresentar a mensagem: 
“Não pode entrar”, mas caso o resultado da condição (idade < 18) for falsa 
(false), a mensagem apresentada é: “Pode entrar”.
Condições mais elaboradas
As condições (testes) utilizados no comando “if” podem ser bem 
mais elaborados que os exemplos apresentados acima. Pode-se, por 
exemplo, concatenar expressões booleanas por meio de operadores 
lógicos, como mostrado no exemplo abaixo.
int idade = 15;
boolean amigoDoDono = true;
if ((idade <18) && (amigoDoDono) == false)
{ 
 System.out.println(“Não pode entrar”); 
}
else
{ 
 System.out.println(“Pode entrar”); 
}
Introdução ao Coding Mobile
43
IMPORTANTE:
Repare que o operador “=” é de atribuição e o operador “==” 
é de comparação.
No exemplo acima, o teste a ser feito é formado por duas condições 
(expressões booleanas). A primeira é a verificação do valor da variável 
idade. A segunda é a verificação da variável amigoDoDono. Resumindo, 
os resultados das duas expressões devem ser verdadeiros para que a 
mensagem apresentada seja: “Não pode entrar”. Caso o resultado de uma 
das expressões seja falsa, a mensagem apresentada será: “Pode entrar”.
O comando swicth
O comando “switch” pode substituir o comando “if-else” para os 
casos em que existem muitas escolhas (seleções) a serem feitas, isto é, 
utilize “if-else” quando precisar testar diferentes variáveis e utilize “swicth” 
quando precisar comparar uma variável com diversos valores. A sintaxe do 
comando “swicth” é a seguinte:
Introdução ao Coding Mobile
44
swicth (<variável>)
{
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;
}
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:”.
Introdução ao Coding Mobile
45
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;
}
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:
While (condição)
{
Bloco de código que deve ser executado enquanto a condição for 
verdadeira.
}
Introdução ao Coding Mobile
46
EXEMPLO
int idade = 15;
while (idade <18)
{
 System.out.println(idade);
 idade = idade + 1;
}
No exemplo acima, o bloco de código será repetido até que o valor 
da variável “idade” se torne igual ou maior que 18, por isso, dentro do bloco 
de repetição deve ser colocado uma linha de comando que altere o valor 
da variável que está sendo testada. Caso a linha de comando “idade = 
idade + 1;” seja retirada do programa, o valor da variável idade não irá se 
alterar e o programa executará o bloco de código indefinidamente, o que 
fará com que o programa trave (entre em loop eterno).
Observando o código do exemplo, verifica-se que primeiro é 
definido o valor da variável idade como sendo o valor 15. Depois faz-
se um teste, que deve ser lido da seguinte maneira: “Enquanto o valor 
da variável idade for menor que 18, execute o bloco de código”. Como 
o resultado deste teste é verdadeiro, o bloco de código é executado e 
o número 15 deve aparecer no console. A linha seguinte faz com que o 
valor da variável idade passe de 15 para 16. O bloco de código acaba e 
o teste é feito novamente. Como 16 ainda é menor que 18, o bloco de 
código é executado mais uma vez. O número 16 é mostrado no console e 
a variável idade tem seu valor alterado para 17. O bloco de código acaba e 
o teste é feito novamente. Como a condição ainda é verdadeira, o número 
17 é apresentado no console e o valor da variável idade passa para 18. O 
bloco de código acaba e o teste é feito mais uma vez. Como dessa vez o 
resultado do teste é falso, o bloco de código não é mais executado e o 
programa segue para as linhas de código que por ventura existam abaixo 
deste bloco de código.
Introdução ao Coding Mobile
47
for
O comando “for” e outro comando de repetição (loop) que permite 
repetir um determinado bloco de código enquanto a condição for 
verdadeira. Porém, o “for” trata a condição de maneira um pouco diferente 
do comando “while”, apresentado acima. A sintaxe do comando “for” é a 
seguinte:
for (inicialização; condição; incremento)
{
Bloco de código que deve ser executado enquanto a condição for 
verdadeira.
}
Como pode ser notado pela sintaxe acima, o comando “for” possui 
três parâmetros:
inicialização: permite ao programador declarar e inicializar uma 
variável;
condição: permite ao programador definir a condição que deve ser 
testada a cada repetição (loop);
incremento: permite ao programador definir qual deve ser o 
incremento que a variável deve receber em cada repetição (loop);
for (int i = 0; i < 10 ; i++) 
{
 System.out.println(i);
}
No exemplo acima, o programa irá apresentar no console os 
números de 0 (zero) a 9 (nove).
Introdução ao Coding Mobile
48
Controlando Loops
O comando break
Como foi verificado nos itens acima, os laços de repetição (loops) 
precisam de condições para serem executados. Porém, existe casos em 
que se faz necessário parar uma repetição se determinada condição for 
encontrada. Para resolver este problema, utiliza-se o comando “break”.
int x, y;
x = 0; y = 50;
 for (int i = x; i < y; i ++)
 {
 if (i%19 == 0)
 {
System.out.println(“Achei um número divisível por 19 entre 
x e y”);
break;
 }
 }
No exemplo acima, o programa quer localizar o primeiro número, 
entre 0 e 49 que seja divisível por 19. Repare que se o comando “break” 
for retirado do código, o programa vai apresentar no console todos os 
números entre 0 e 49 que sejam divisíveis por 19, mas não é isso que se 
quer. O que se quer é apenas o primeiro. Por isso, uma vez que o primeiro 
número divisível por 19 foi encontrado, utiliza-se o comando “break” 
para abortar a execução do laço de repetição (for), pois ele não é mais 
necessário.
Introdução ao Coding Mobile
49
O comando continue
Em outros casos, faz-se necessário permitir que o laço de repetição 
não execute o loop para uma determinada condição. Nestes casos, utiliza-
se o comando continue.
for (int i = 0; i < 100 ; i ++)
{
if ( i > 50 && i < 60)
{
 continue;
}
System.out.println(i);}
No exemplo acima, o programa vai mostrar os números de 0 a 50 e 
de 60 a 99, pois quando os valores da variável i forem maiores que 50 e 
menores que 60, o “loop” será ignorado.
No desenvolvimento de um programa mais complexo ou 
aprimorado, normalmente utiliza-se não apenas um tipo de estrutura de 
controle, mas sim uma mescla das várias descritas acima. É muito comum 
utilizar uma estrutura de controle de seleção (if) dentro de uma estrutura 
de controle de repetição (for ou while).
IMPORTANTE:
Toda a base da programação está no entendimento dos 
conceitos de estrutura de controle apresentados nesta 
unidade. É praticamente impossível construir qualquer 
bloco de código significativo sem dominar esses conceitos. 
Por isso, para que você realmente aprenda a programar 
não passe para o próximo módulo sem ter entendido muito 
bem os conceitos apresentados aqui.
Introdução ao Coding Mobile
50
Classes em Java
Introdução
Como foi estudado na disciplina de Introdução ao Coding Web, 
uma classe é composta por Nome, Lista de Atributos e Lista de Métodos. 
Os atributos, como visto anteriormente neste material, são as variáveis 
de Instância. Os métodos e, por fim, as classes propriamente ditas, serão 
tratadas neste tópico.
Métodos
Um Método de uma Classe define o comportamento que a classe 
deve ter quando este Método for chamado numa mensagem.
Quando uma Classe recebe uma mensagem, esta mensagem 
normalmente informa qual método ela deve executar. A Classe, então, 
redireciona a execução do programa para o código que está contido 
dentro do método chamado. Quando o bloco de código daquele método 
acaba, o programa retorna à execução do programa para a linha de código 
seguinte a que chamou o método.
O termo “chamar um método” é utilizado neste material para dizer 
que o código que está contido dentro daquele método deve ser executado.
Para declarar um método público em Java utilizamos a seguinte sintaxe:
public <tipo de retorno> <nome do método>
{
 Bloco de código que deve ser executado quando este método 
foi chamado.
}
Onde:(1) O termo “public” define que o método pode ser acessado 
por outras classes que instanciarem a classe que contem este método. 
Caso se queira tornar este método inacessível para outras classes, é 
necessário substituir o termo “public” por “private”; (2) O <tipo de retorno> 
Introdução ao Coding Mobile
51
informa ao programa se qual o tipo de dado que o método irá retornar 
quando for executado. Para o <tipo de retorno> 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”. 
Caso o método possua algum tipo de retorno, a última linha do método 
a ser executada é o comando “return” acompanhado da variável que 
armazena o valor que deve ser retornado; (3) Para o <nome do método> 
utiliza-se qualquer identificador válido que ainda não tenha sido utilizado 
para declarar outros elementos nesta mesma classe. O nome do método 
deve sempre ser sucedido 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.
Para este exemplo, crie um novo pacote, chamado de exercicio6. 
Dentro deste pacote, crie uma classe chamada de Principal (que deve 
conter o método “main”. O conteúdo desta classe deve ser a seguinte:
Figura 32 – Exemplo de chamada de método.
Fonte: Autor
Explicando o exemplo acima:
1. Quando o programa acima é executado, o primeiro método a ser 
chamado quando é o método “main” (linha 12) conforme já foi dito 
anteriormente, neste material. 
2. Dentro do método “main”, três variáveis são declaras (linhas 13 a 15) 
e têm seus tipos e valores definido. São elas: a, b e c. 
Introdução ao Coding Mobile
52
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, onde o método 
soma (que foi chamado na linha 16) recebe os dois parâmetros, 
como sendo “X” e “Y”. Isto quer dizer que apenas dentro do método 
soma() a variável “a” será chamada de “X” e a variável “b” será 
chamada 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, onde 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 na 
os 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:
Introdução ao Coding Mobile
53
Figura 33 – Exemplo 2 de chamada de métodos.
Fonte: Autor Fonte: Autor
Classes
Como foi verificado anteriormente, neste material, a Programação 
Java é baseada em Classes. Isto quer dizer que toda a estrutura da 
programação Java está baseada no envio e recebimento de mensagens 
entre as classes, isto é, uma classe a chamar a outra através de métodos.
Introdução ao Coding Mobile
54
Para melhor entendimento do que seja uma classe e de como 
podemos cria-las utilizando a linguagem Java, imagine a classe 
CALCULADORA especificada na figura abaixo (Figura 34).
Figura 34 – 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)
Repare que esta classe possui apenas um atributo, chamado 
‘resultado’ e possui quatro métodos, uma para cada operação matemática 
básica.
Para implementar esta 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 figura abaixo 
mostra como deve ficar o Package Explorer do seu projeto.
Figura 35 – Pacote Calculadora
Fonte: Autor
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:
Introdução ao Coding Mobile
55
Figura 36 – Pacote Calculadora com duas classes
Fonte: Autor
3. Clique duas vezes sobre a classe principal.java e o Eclipse exibirá 
a seguinte tela:
Figura 37 – Classe Principal.java – com o método MAIN
Fonte: Autor
Repare que esta classe possui 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:
Figura 38 – Classe Calc – sem o método MAIN
Fonte: Autor
Repare que a classe “Calc” não deve ter o método “main”. Este 
método só deve estar presente na classe principal do pacote.
Introdução ao Coding Mobile
56
Para implementar o exemplo, o nosso trabalho consiste em traduzir 
o “desenho” representado na figura 34 (da classe calculadora) para dentro 
do código Java – classe “Calc”.
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)
Vamos demonstrar passo a passo a implementação da classe calculadora:
1. Acrescente um bloco de comentário padrão e declare o atributo 
na classe “calc”.
Figura 40 – Exemplo – parte I
Fonte: Autor
2. Acrescente os métodos descritos na figura 39 na classe “calc”.
Introdução ao Coding Mobile
57
Figura 41 – Exemplo – Parte II
Fonte:Autor
Note que o código apresentado acima deve apresentar 4 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 figura abaixo (Figura 42):
Figura 42 – Identificação de erro do código.
Fonte: Autor
Introdução ao Coding Mobile
58
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 este 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’, como 
se pode ver na figura 42.
Para o nosso caso, a solução mais adequada é inserir o comando 
“return”. O nosso código fica, então, como mostrado na figura abaixo:
Figura 43 – Código corrigido
Fonte: Autor
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, para evitar erro do 
programa em tempo de execução, pois, como você deve 
saber, não existe resultado para a divisão por zero.
Introdução ao Coding Mobile
59
Figura 44 – métodos implementados na classe Calc
Fonte: Autor
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 a 
mesma instancie a classe “Calc” 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 figura abaixo.
Introdução ao Coding Mobile
60
Figura 45 – Classe principal a instanciar a classe Calc
Fonte: Autor
Note que para se instanciar uma classe, isto é, criar um objeto, 
deve-se usar a seguinte notação:
<tipo da classe> <nome do objeto> = new <nome da classe>();
Onde:
 • <tipo da classe> tem a mesma função que o <tipo da variável> 
utilizado nos tópicos anteriores, neste material;
 • <nome do objeto> é o nome que o programador dará para o objeto 
que está sendo criado;
 • <new> é uma palavra reservada que informa ao programa que o 
programador está criando uma nova instância de uma classe;
 • <nome da classe> é o nome que o programador deu para a classe 
que ele está querendo instanciar. Sempre deve ser seguindo 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 desta linha o programa entende que existe um objeto 
chamado “C” e que o mesmo 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.
Muito bem. Execute o programa e verá que o resultado da soma 
será apresentado no console.
Introdução ao Coding Mobile
61
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 a 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 que este método deve receber dois parâmetros do tipo especificado. O 
Código deve ficar mais ou menos assim:
Figura 46 – método media()
Fonte: Autor
Agora faça uma chamada ao método “media()”, a partir do método 
“main” da classe principal.
Figura 47 – inserindo a chamada ao método media() na classe MAIN
Fonte: Autor
Introdução ao Coding Mobile
62
Polimormismo, Interface e Classes Abstratas
Polimorfismo
O polimorfismo ocorre quando o programa é implementado de 
maneira que “o mesmo método” pode responder de diferentes formas.
Da mesma maneira como fizemos quando este conceito foi 
apresentado para a linguagem PHP (introdução ao Coding Web – Unidade 4), 
entendemos como necessário a apresentação da definição formal. Aqui está:
Polimorfismo é a 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 esta ideia, usaremos aqui o mesmo exemplo que trabalhamos 
com PHP. Isso permite a você perceber as similaridades e diferenças entre as 
duas linguagens de programação para tratar este conceito. 
Imagine o cenário representado pelo diagrama abaixo:
Figura 48 – representação gráfica da herança entre duas classes.
Conta
Agencia
Conta
Saldo
Registrar_Conta(Ag, Cta, S)
Depositar(Valor)
Sacar(Valor)
Conta_Poupanca
Sacar(Valor)
Fonte: Autor
Introdução ao Coding Mobile
63
Primeiro vamos implementar a classe Conta. 
Para implementar esta classe, crie um novo pacote no projeto 
Exe01, chamado exercicio7. Dentro deste pacote, crie uma classe Conta, 
sem o método “MAIN”, declare os atributos e implemente os métodos, de 
acordo com a figura 48, acima. O seu código deve ficar mais ou menos 
assim:
Figura 49 – Classe Conta
Fonte: Autor
Agora que temos a classe Conta, crie uma nova classe, no mesmo 
pacote ‘exercicio7’, chamado Conta_Poupanca. Esta classe deve ser uma 
subclasse da classe Conta (figura 49). Ser uma subclasse significa herdar 
as características e comportamentos da classe mãe (ou super classe).
IMPORTANTE:
Caso você não se recorde do conceito de herança entre 
classes, que foi visto na disciplina de “introdução ao coding 
Web”, aqui vai, novamente: 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).
Introdução ao Coding Mobile
64
Conforme podemos verificar na figura 48, 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:
Figura 50 – Conta Poupança.
Fonte: Autor
Para o conteúdo do método sacar da classe ContaPoupança 
podemos imaginar que o Valor não pode ser maior que o Saldo da conta, 
verificação que não acontece na classe Conta (figura 49). Então, nosso 
código fica mais ou menos assim:
Figura 51 – Classe Conta Poupança.
Fonte: Autor
Note que esta classe ContaPoupança herda (extends) da classe 
Conta, criada anteriormente. Repare também que a classe filha 
“contaPoupanca” possui 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 
e diferente do conteúdo do método sacar na classe filha. 
Introdução ao Coding Mobile
65
Para testar o funcionamento da classe “conta” e da classe 
“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:
Figura 52 – Classe Principal (com método MAIN) para testar as classes Conta e 
ContaPoupança.
Fonte: Autor
Note que o método Sacar(Valor), apresentado na figura acima 
verifica se a quantia a ser sacada é maior que o valor do saldo da conta. A 
resposta apresentada no console deve ser o seguinte:
Figura 53 – Resultado da execução do códido da figura 52.
Fonte: Autor
Interface
Uma interface é um tipo composto (ou referência) em Java. Pode ser 
considerada como uma classe com métodos abstratos. Alguns tutoriais 
java, como por exemplo o site TutorialPoint , consideram que escreveruma interface é similar a escrever uma classe, porém, uma classe deve 
descrever os atributos e comportamentos de um objeto e a interface, por 
sua vez, contém a descrição dos comportamentos que uma classe deve 
implementar.
Introdução ao Coding Mobile
66
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 
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 por exemplo: 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:
Figura 54 – Interface Conta
Fonte: Autor
Esta interface Conta foi criada num novo pacote, chamado 
exercicio8, no mesmo projeto exe01.
Se criarmos uma classe que implemente (implements) a interface 
Conta, ela deve ser assim:
Introdução ao Coding Mobile
67
Figura 55 – Classe ContaCorrente
Fonte: Autor
Repare que ao lado da marcação da linha3 existe uma “x” a indicar 
que ali existe um erro. Se pararmos o ponteiro do mouse sobre o “x”, 
teremos a seguinte informação:
Figura 56 – Classe ContaCorrente
Fonte: Autor
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 é?! Isto permite que você crie uma espécie de ‘contrato’, no 
sentido de exigir que os programadores que, por ventura, 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
Como você deve lembrar, já apresentamos este conceito quando 
estudamos a linguagem PHP, na disciplina de Introdução ao Coding Web 
– Unidade 4. 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.
Introdução ao Coding Mobile
68
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.
Diferente do que acontece com a interface, uma classe qualquer 
pode herdar as características e comportamentos da classe abstrata. 
Mas, 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, apresentada 
na figura 54 numa classe abstrata. Crie um novo pacote, chamado 
exercicio9 e, dentro dele, crie uma classe, sem o método “MAIN”. Antes 
de apertar o botão “FINISH”, selecione a opção ‘abstract’, como mostrado 
na figura abaixo:
Introdução ao Coding Mobile
69
Figura 57- Criando uma classe abstrata
Fonte: Autor
Dentro da classe Conta, insira o seguinte conteúdo:
Figura 58 – Classe abstrata
Fonte: Autor
Note que apenas dois métodos são abstratos, o que significa que 
a classe abstrata conta pode superclasse de uma classe ContaCorrente, 
por exemplo. Esta subclasse poderá herdar (extends) do atributos e 
métodos já implementados na classe Conta e deverá obrigatoriamente 
implementar o conteúdo dos métodos abstratos ‘Depositar’ e ‘Sacar’.
Introdução ao Coding Mobile
70
Bem. Foi uma longa caminhada e espero 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 e nosso intuito aqui não 
foi de esgotar o assunto, mas sim de apresentar o que pensamos serem 
os conceitos fundamentais.
Verifique os links e livros indicados nas referências bibliográficas, 
com destaque para os livros de Deitel (2003) e Mattos (2007)
Introdução ao Coding Mobile
71
REFERÊNCIAS
CLARO, D., & SOBRAL, J. (2008). Programação em JAVA. Florianópolis, 
SC: Copyleft Pearson Education. Acesso em 06 de Set. de 2018, disponível 
em http://www.faeterj-rio.edu.br/downloads/bbv/0031.pdf
CORDEIRO, F. (2016). Android Studio (3 ed.). AndroidPro.
CORDEIRO, F. (2017). Android Aprendiz. AndroidPro. Fonte: https://
www.androidpro.com.br/
DALL’OGLIO, P. (2016). PHP - Programando com Orientação a Objetos 
(3 ed.). SP, SP, Brasil: Novatec Editora. Acesso em 30 de Ago. de 2018
DEITEL, H., & DEITEI, P. (2003). Java, como programar (4 ed.). Porto 
Alegre: Bookman.
GOSLING, J., & McGILTON, H. (1995). The Java Language Environment. 
Mountain View,, California, EUA: Sun Microsystems, Inc.
MATTOS, E. (2007). Programação de softwares em Java. SP: Digerati 
Books.
MEIRELLES, A. (2009). Smartphones, Guia Prático - Android. Acesso 
em 05 de Set. de 2018, disponível em Hardware.com.br: https://www.
hardware.com.br/livros/smartphones/android.html
Oracle.com. (2018). Java Documentation. Acesso em 13 de Set. de 
2018, disponível em Oracle: https://docs.oracle.com/javase/tutorial/
getStarted/intro/definition.html
Introdução ao Coding Mobile
	Java Básico
	O Primeiro Projeto Java
	A Primeira Classe Java
	Estrutura Básica da Linguagem Java
	Introdução
	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
	Atributos Públicos
	Atributos Privados
	Operadores
	Operadores Aritméticos
	Operadores de Atribuição
	Operadores de Incremento e Decremento
	Operadores Relacionais
	Operadores Booleanos
	Operador Ternário
	Estrutura de Controle de Seleção e de Repetição
	Estrutura de Controle de Seleção
	Comando if
	Comando if – else
	Condições mais elaboradas
	O comando swicth
	Estrutura de Controle de Repetição
	while
	for
	Controlando Loops
	O comando break
	O comando continue
	Classes em Java
	Introdução
	Métodos
	Classes
	Polimormismo, Interface e Classes Abstratas
	Polimorfismo
	Interface
	Declarando uma Interface
	Classes Abstratas