O documento apresenta um guia rápido de referência sobre variáveis, tipos de dados, operadores e fluxos de controle na linguagem Java, incluindo a declaração e inicialização de variáveis, tipos primitivos, constantes, operadores aritméticos, relacionais e lógicos. Também aborda comentários, strings, entrada e saída de dados, e convenções de codificação.

1. Guia Rápido de Referência Java
Mario Jorge Pereira
mariojp@gmail.com
http://www.mariojp.com.br
Variáveis e Tipos de Dados
As variáveis são referências (rótulos) a um local onde
serão armazenados dados, ou seja, a variável é um nome
que guarda um valor, que pode ser lido ou alterado.
Cada variável tem um tipo associado e as linguagens de
programação fornecem esses tipos. O Java possui 8
tipos básicos (primitivos ou pré-definidos).
Tipo Descrição
byte
Representa números inteiros de 1 byte (8 bits)
entre -128 e 127
short
Representa números inteiros de 16 bytes entre
-32.768 a 32.767
int
Representa números inteiros de 32 bytes entre
-2.147.483.648 e 2.147.483.647
long
Representa números inteiros de 64 bytes entre
-263 e 263-1
float
Representa números com ponto flutuante de 32
bytes entre 1.40239846e-46 e 3.40282347e+38
double
Representa números com ponto flutuante de 64
bytes entre 4.94065645841246544e-324 e
1.7976931348623157e+308
char
Representa um caracter alfanumérico Unicode de
2 bytes (16 bits)
boolean
Representa os valores de 1 bit que podem ser
true (verdadeiro) ou false (falso)
Declarando e inicializando
Definição: tipo variável [= valor];
Exemplo
//declarando
int contador;
//declarando e inicializando
char letra = 'a';
//declarando, inicializando e alterando valor
double dinheiro; //declarando
dinheiro = 100.0; //inicializando
dinheiro = 10.0; //alterando valor
Constantes
As Constantes, diferente das variáveis, não podem ter
o seu valor alterado, ou seja, não podemos atribuir um
novo valor.
Em Java conseguimos isso adicionado o modificador
final na sua declaração
Definição e Exemplo
//Definição:
final tipo CONSTANTE = valor;
//Exemplos:
final int MAIOR_IDADE = 18;
final char MASCULINO = 'M';
final double PI = 3.14;
Operadores Aritméticos
Operadores Descrição
+ Adição
- Subtração
/ Divisão
* Multiplicação
% Modulo da divisão (Resto da Divisão)
++ Incremento
-- Decremento
Exemplo
//Definição:
variavel1 Operador [variavel2];
//Exemplos:
// x e y variáveis de tipos numéricos
int x = 10;
int y = 5;
// resultado da operação é do tipo numérico
x + y; //adição
x – y; //subtração
x / y; //divisão
x * y; //multiplicação
x % y; //modulo
x++; //incremento ( x = x + 1)
x--; //decremento ( x = x – 1)
//Outro exemplo atribuindo o resultado a uma variavel
int resultado = x + y;
Operadores Relacionais
Operadores Descrição
== Igual
!= Diferente
> Maior que
>= Maior ou igual que
< Menor que
<= Menor ou igual que
Exemplo
// x e y variáveis de tipos numéricos
// resultado booleano
x == y; //igual
x != y; //diferente
x > y; //maior que
x <= y; //menor ou igual que
Operadores Lógicos (booleanos)
Operador Descrição
&& E (AND)
|| OU (OR)
! NÃO (NOT)
Exemplo
//Definição:
[variavel2] Operador variavel1;
//Exemplos:
// a e b variáveis de tipo booleano
// resultado booleano
boolean a = true;
boolean b = false;
a && b;
a || b;
!a;
a || b && !b;
// Podemos utilizar na mesma expressão:
//x e y variáveis de tipos numéricos
//operadores relacionais que tem resultado booleanos
//operadores lógicos
int x = 1;
int y = 1;
x > y || x < y;
x < 10 || y > 0;

2. Tabela Verdade
A B
A &&
B
A || B !A !B
true true true true false false
true false false true false true
false true false true true false
false false false false true true
Comentários
// Comentário de 1 linha
/* */ Comentário de múltiplas linhas
/** */ Comentário para documentação
Exemplo
// Texto de uma linha
/*
Texto em
Duas ou mais linhas
*/
/**
Textos para javadoc
*/
String
Descrição
Representa uma sequência de caracteres, ou seja, pode
armazenar uma lista de char.O valor literal de uma
String deve estar entre aspas duplas (“valor”).
Declarando e inicializando
Definição: String variável [= “valor”];
Exemplo
Exemplos:
//declarando
String palavra;
//declarando e inicializando
String frase = “Olá Mundo!”;
String letra = “a”;
Concatenação (+)
Operador + com Strings é utilizado para concatenar
duas variáveis sendo pelo menos uma delas uma String
Exemplo
String nome = "Pedro";
String sobrenome = "Lucas";
//imprime no console Pedro Lucas
System.out.println(nome + " " + sobrenome);
int idade = 5;
//imprime no console Pedro idade: 5
System.out.println(nome + " idade: " + idade);
Fluxos de Controle
Descrição
Estrutura da linguagem que permite selecionar, pular
ou repetir trechos de código.
Condição Booleana (condição)
Uma condição booleana é qualquer expressão que tenha
como resultado true (verdadeiro) ou false (falso)
if (condição)
if (condição) {
instruções;
}
//Exemplo
int i = 0;
if(i < 10){
System.out.println(i);
}
if (condição) ... eles …
if (condição) {
instruções;
} else {
instruções;
}
//Exemplo
int i = 0;
if(i > 10){
System.out.println(“Verdadeiro”);
}else{
System.out.println(“falso”);
}
while (condição) ...
while (condição) {
instruções;
}
//Exemplo
int i = 0;
//Só executa o conteúdo se a condição for verdadeira
//Algo deve ocorrer para sair do loop (i++)
while (i<10) {
System.out.println(i);
i++;
}
//Exibe de 0 a 9 no console
do ... while (condição);
do {
instruções;
} while (condição);
//Exemplo
int i = 0;
//Sempre executa o conteúdo a primeira vez
//mesmo com a condição falsa
//Algo deve ocorrer para sair do loop (i++)
do {
System.out.println(i);
i++;
} while ( i < 10 );
//Exibe de 0 a 9 no console
for ( inicialização ; condição ; incremento ) ...
for (initialization; termination-clause; iteration) {
instruções;
}
//Exemplo
//Só executa o conteúdo se a condição for verdadeira
//Algo deve ocorrer para sair do loop (i++)
for (int i= 0; i < 10; i++) {
System.out.println(i);
}

3. //Exibe de 0 a 9 no console
Programa Básico
O mínimo de código para executar uma aplicação Java.
É necessario um arquivo de texto com a extensão .java,
que deve ter o mesmo nome da Class.
Para compilar use o comando: javac NomeDoArquivo.java
Se existir algo errado serão apresentados erro de
compilação, caso contrário um arquivo chamado
NomeDoArquivo.class será criado.
Para executar use o comando: java NomeDoArquivo
Inicia o programa que pode apresentar erros de
execução e/ou lógica (runtime).
Estrutura do Mínima
public class NomeDaClasse {
public static void main(String args[ ]){
instruções;
}
}
Convenções de codificação Java
Nome da Classe
Nomes de classe devem ser substantivos, iniciar em
maiúscula depois minúsculas com a primeira letra de
cada palavra interna em maiúscula.
Prefira os nomes simples e descritivo.
Evite siglas e abreviaturas.
Exemplos:
class Conta
class ContaCorrente
class TrabalhoDisciplina
Nome de Variável
Nomes de variáveis devem ser em minúsculo, em caso de
nomes compostos a primeira letra de cada palavra
interna em maiúscula.
Prefira nomes curtos, significativos.
Exceto para variáveis temporárias, nesse caso é comum
usar i, j, k (inteiros), c, d, e (caracteres)
Variáveis não podem começar com underscore ("_") ou $.
Exemplos:
int i;
char c;
float minhaAltura;
Constantes
Nomes de variáveis declaradas como constantes devem
ter todas em letras em maiúsculas com palavras
separadas por underscore ("_").
Exemplos:
static final int ALTURA_MINIMA = 4;
static final double PI = 3.14;
static final int NUMERO_DA_CASA = 13;
Dicas e Atalhos do Eclipse
Indentar todo o código automaticamente
Use Ctrl + Shift + F
Indentar o código selecionado
Use Ctrl + I
Organizar Import das Classes
Ctrl + Shift + O
Duplica a linha atual ou selecionada para cima
Ctrl + Alt + Seta para cima
Duplica a linha atual ou selecionada para baixo
Ctrl + Alt + Seta para baixo
Move a linha para cima
Alt + Seta para cima
Move a linha para baixo
Alt + Seta para baixo
Exclui linha
Ctrl + D
Adiciona/Remove comentários de linha (//)
Selecione as linhas e use Ctrl + /
Adiciona comentário de bloco (/* ... */)
Selecione as linhas e use Ctrl + Shift + /
Remove comentário de bloco (/* ... */)
Selecione as linhas e use Ctrl + Shift +
Gerar System.out.println(“”);
Digite syso ou sysout e pressione Ctrl + Espaço
Exibe Lista de atalhos
Use Ctrl + Shift + L
Quick Fix – Exibe Menu de contexto
Coloque o cursor na posição e use Ctrl + 1
Quick Access – Busca onipresente do Eclipse
Use Ctrl + 3
Eclipse Avisos e Erros
Avisos e sublinhado de amarelo
Isso não é erro apenas um aviso de que algo pode dar
errado ou não faz sentido para ele. Com o mouse em
cima do um texto explicantivo aparece (em ingles).
Nesse caso o codigo compila e pode ser executado.
Exemplo:
The value of the local variable ... is not used
O valor da varivel local ... não esta sendo usada.
Existe uma variavel declarada e inicializada que não
esta sendo usada ou lida.
public class Aviso {
public static void main(String[] args){
int i = 0; // Aviso aqui
int j = 1;
System.out.println(j);
}
}
The value of the local variable i is not used
A variavel i não está sendo utilizada para nada.
ou Erros e sublinhado vermelho
Nesses 2 casos existe um erro e o codigo não vai
compilar
Exemplo:
... cannot be resolved to a type
... o tipo não pode ser resolvido
Está tentando declarar uma variavel de um tipo que não
existe.
public class Erro {
public static void main(String[] args){
string s = “texto”;
System.out.println(s);
}
}

4. string cannot be resolved to a type
O tipo string não existe e por isso o compilador não
pode resolver. Troque de string para String.
Entrada e Saída / IO – Input Output
Saída / Output
Podemos usar a tela atraves do console/terminal,
arquivos e outros dispositivos de saída.
Para utilizar o terminal no código Java são usados os
seguintes metodos:
//Exibe o que é passado para o metodo.
System.out.print([variavel ou valor literal]);
// Exibe o que é passado para o metodo e
//passa para próxima linha
System.out.println([variavel ou valor literal]);
Exemplos:
//Exibe:
//Pedro Lucas|
//Cursor (“|”) aguarda na mesma na linha
System.out.print(“Pedro ”);
System.out.print(“Lucas”);
//Exibe:
//Pedro
//Lucas
//|
//Cursor (“|”) foi para próxima linha
System.out.println(“Pedro ”);
System.out.println(“Lucas”);
//Exibe:
//10
//|
//Cursor (“|”) foi para próxima linha
int i = 10;
System.out.println(i);
Entrada / Input
Podemos usar diferentes formas e metodos de entrada,
desde a leitura de dados digitados no console/terminal
atraves do teclado, leitura de arquivos e etc.
Para a ler dados digitados no terminal podemos
utilizar a classe Scanner desde o Java 1.5 / Java 5.
Scanner
Deve ser declarado na sua Classe o import:
//import da Classe Scanner
import Java.util.Scanner;
//import do pacote java.util
//que contem a Classe Scanner
import Java.util.*;
Declarando e Inicializando
Scanner variavel = new Scanner(fonte);
//Ler dados do teclado/console
//Declarando e inicializando o Scanner para o teclado
//fonte: System.in
Scanner teclado = new Scanner(System.in);
//Ler dados do arquivo
// Declarando e inicializando um Arquivo (File)
// import java.io.File
File arquivo = new File(“caminhoArquivo”)
//Declarando e inicializando o Scanner para um Arquivo
//fonte: java.io.File
Scanner dados = new Scanner(arquivo);
Metodos do Scanner
.nextInt() Ler número inteiro
.nextFloat() Ler número real
nextDouble() Ler número real
.next() Ler palavra simples sem espaço
nextLine() Ler palavras e esvaziar buffer
System.in.read() Ler caracter (não usa o Scanner) ;)
Exemplos:
//importando a classe Scanner
import java.util.Scanner;
public class Exemplo {
public static void main(String[] args) throws
Exception {
//declarando e inicializando para ler do teclado
Scanner tc = new Scanner(System.in);
System.out.print(“Digite um número inteiro: ”);
//lendo numero inteiro do teclado
int i = tc.nextInt();
//imprime a variavel i
System.out.println(i);
//limpa buffer
tc.nextLine();
System.out.print(“Digite um número real: ”);
//lendo numero real do teclado
double d = tc.nextDouble();
//imprime a variavel d
System.out.println(d);
//limpa buffer
tc.nextLine();
System.out.print(“Digite um caractere: ”);
//lendo caracter do teclado
char c = (char) System.in.read();
//imprime a variavel c
System.out.println(c);
//limpa buffer
tc.nextLine();
System.out.print(“Digite uma palavra: ”);
//lendo palavra do teclado
String s = tc.next();
//imprime a variavel s
System.out.println(s);
//limpa buffer
tc.nextLine();
System.out.print(“Digite uma frase: ”);
//lendo palavras do teclado
String sc = tc.nextLine();
//imprime a variavel s
System.out.println(sc);
//Fecha o Scanner
tc.close();
}
}
Para MAC OSX:
Onde-se lê “Ctrl”, leia-se “Command”.
Versão 2.0
Autor:
Mario Jorge Pereira - @mariojp
mariojp@gmail.com
Contribuições:
Silvio Luiz - @silvioluizzz