Fundamentos Básicos do Java

-2

Sumário

Introdução ao Java – Fundamentos básicos............................................................................... 3

1.1. Introdução....................................................................................................................... 4
1.2. Classes ........................................................................................................................... 5
1.3. Variáveis........................................................................................................................ 10
1.3.1. Tipos primitivos .................................................................................................................. 11
1.3.2. Variáveis literais.................................................................................................................. 14
1.3.3. Variáveis de referência........................................................................................................ 14
1.3.4. Variáveis de instância ......................................................................................................... 14
1.4. Métodos ........................................................................................................................ 16
1.4.1. Retorno de um método ....................................................................................................... 20
1.4.2. Métodos com parâmetros ................................................................................................... 23
1.5. Controle de fuxo: if / else / while / for / switch ............................................................27
1.5.1. if.......................................................................................................................................... 27
1.5.2. switch ................................................................................................................................. 29
1.5.3. break ................................................................................................................................... 31
1.5.4. default ................................................................................................................................. 32
1.5.5. for ....................................................................................................................................... 33
1.5.6. For avançado ...................................................................................................................... 34
1.5.7. while ................................................................................................................................... 35
1.5.8. do / while............................................................................................................................. 36
1.6. Construtores................................................................................................................. 37
1.7. Operadores e expressões.............................................................................................. 41
1.7.1. Operador de atribuição........................................................................................................ 41
1.7.2. Operadores aritméticos....................................................................................................... 41
1.7.3. Operadores de incremento e decremento...........................................................................42
1.7.4. Operadores lógicos.............................................................................................................. 42
1.7.5. Operadores relacionais........................................................................................................ 43
1.8. Referências Bibliográfcas............................................................................................ 44

Índice de tabelas

Índice de Figuras
 Introdução ao Java – Fundamentos básicos - 3

Introdução ao Java – Fundamentos

básicos
 Introdução ao Java – Fundamentos básicos - 4

1.1. Introdução

Quando se aprende uma nova linguagem de programação, alguns tópicos são

muito importantes para podermos iniciar nosso aprendizado. O propósito desta aula é
fazer uma revisão sobre estes tópicos de maneira bem didática para que a base seja
bem formada. Estes tópicos também são vistos quando se aprende outra linguagem
de programação, logo este assunto é considerado tranquilo, mas não deve ser pulado.
Não queime etapas, na pior das hipóteses, você sairá mais consciente de que domina
os tópicos aqui apresentados. Lembre-se: “Recordar é viver!”.

Veremos a estrutura básica do Java com mais detalhes nessa apostila, portanto
leia com bastante atenção e anote as dúvidas para discussão nos fóruns.
Classifcamos como tópicos iniciais o conceito de classes, variáveis, objetos, métodos,
controle de fuxo, operadores.

É importante ressaltar que o objetivo desta apostila é ser um tutorial

mostrando exemplos de código e conceitos importantes. Esta apostila não
pretende ser um guia de referência sobre os assuntos aqui tratados. Já
existem excelentes materiais de referência na Internet, como, por exemplo,
o JavaDoc.
 Introdução ao Java – Fundamentos básicos - 5

1.2. Classes

O conceito de classe é um dos alicerces da linguagem Java. Isso é

consequência do fato de que Java é uma linguagem criada baseada no paradigma de
programação conhecida como orientação à objetos. Uma classe defne a forma e a
natureza de um objeto. Por isso, o conceito de classe forma a base da programação
orientada a objetos em Java.

Qualquer conceito que se queira implementar em um programa Java deve ser

encapsulado dentro de uma classe. Pelo fato das classes serem tão fundamentais em
Java, esta lição e as próximas tratarão deste assunto com profundidade. Na verdade,
no momento em que você escreveu seu primeiro programa em Java, você já fez uso
das classes. Talvez o mais importante a entender sobre as classes é que elas defnem
um novo tipo de dado.

Por exemplo, se criarmos uma classe Java chamada “NovoTipo”, podemos a

partir daí criar objetos do tipo “NovoTipo”. Portanto, uma classe é a defnição de um
objeto, e um objeto é um exemplar de uma classe.

Como um objeto é uma instância de uma classe, muitas vezes veremos essas
duas palavras, objeto e instância, sendo usadas de forma intercambiável. Quando
defnimos uma classe, precisamos declarar com exatidão sua forma e sua natureza.
Isso é feito especifcando-se os dados que ela contém e as funções (métodos) que
operam sobre esses dados.

Embora classes muito simples possam conter apenas funções (métodos) ou

apenas dados (variáveis), no mundo real, a maior parte das classes contém ambos.
Como veremos, o código de uma classe defne a interface utilizada para acessar
seus dados. Uma classe é declarada com o uso da palavra-chave class.

Não se preocupe muito se alguns termos por agora não fazerem sentindo,
ou, estranho. A medida que vamos avançando no curso e praticando as
dúvidas teóricas tendem a serem solucionadas através da pratica.
 Introdução ao Java – Fundamentos básicos - 6

A programação Orientada à Objetos tem como característica imitar o "mundo

real" por meio de abstrações. Como primeiro exemplo, iremos utilizar uma classe
muito simples. Criaremos criar uma classe que representa uma "Pessoa" e,
coerentemente, será chamada de classe Pessoa. Eis a defnição da classe Pessoa:

class Pessoa {
double largura;
double altura;
} // fm da classe Pessoa

Observe que uma "Pessoa real" poderia ter várias outras características,
como: idade; peso; etc. Nesse nosso exemplo, limitamos nossa abstração
somente às propriedades largura, altura. Nossa classe Pessoa defne duas
variáveis de instância: “largura” e “altura”.

Variáveis de instância é o nome que damos às variáveis ou dados contidos

dentro de uma classe. São elas que defnem as propriedades de um objeto da classe
Pessoa. Observe que, por enquanto, a classe Pessoa não contém nenhum método.

Como dissemos, uma classe defne um novo tipo de dado. Nesse caso, o novo
tipo de dado é chamado Pessoa. Usaremos esse nome para declarar objetos do tipo
Pessoa. É importante lembrar que a declaração de uma classe apenas não cria um
objeto. Assim, a declaração não faz com que um objeto do tipo Pessoa passe a existir.

Para que seja criado, de fato, um objeto do tipo Pessoa, usamos o seguinte
comando: Pessoa pessoa1 = new Pessoa(); // cria um objeto do tipo Pessoa chamado
pessoa1.

Depois que o comando for executado, "pessoa1" será uma instância de Pessoa,
passando a ser uma realidade física. Por enquanto, não se preocupe com os detalhes
desse comando.
 Introdução ao Java – Fundamentos básicos - 7

Novamente, cada vez que criamos uma instância de uma classe, estamos
criando um objeto que contém sua própria cópia de cada variável de instância
defnida pela classe. Portanto, cada objeto Pessoa contém cópias próprias das
variáveis de instância “largura” e “altura”.

Para acessar essas variáveis, usamos o operador “ponto” ('.'). Ele conecta o
nome do objeto ao nome de uma variável de instância. Por exemplo, para atribuir o
valor 50 à variável “largura” de “pessoa1”, usamos o seguinte comando:

Pessoa1.largura = 50;

Eis o que esse comando diz ao compilador: atribua à cópia da variável

“largura” que está contida dentro do objeto “pessoa1” o valor 50. Em geral,
utilizamos o operador “ponto” para acessar tanto as variáveis de instância quanto os
métodos de um objeto.
 Introdução ao Java – Fundamentos básicos - 8

Eis um programa completo que utiliza a classe Pessoa, baixe o código

PessoaDemo.java no Moodle:

Quando esse programa for compilado, veremos que dois arquivos “.class”
foram criados: PessoaDemo.class e Pessoa.class .
 Introdução ao Java – Fundamentos básicos - 9

O compilador Java automaticamente coloca cada classe em um arquivo

“.class” separado, não importando se originalmente as duas classes, “Pessoa” e
“PessoaDemo” estão ou não no mesmo arquivo fonte.

Se quiséssemos, poderíamos colocar cada classe em seu próprio arquivo fonte,

chamando-os de “Pessoa.java” e “PessoaDemo.java”, respectivamente.

Para rodar esse programa, devemos executar a classe “PessoaDemo.class”,

porque é ela que contém o método main(), e isso é feito com o seguinte comando:

java PessoaDemo

O programa gera a seguinte saída:

Volume de Pessoa1 = 1000.0

Observação: se estiver usando o Eclipse, não precisa digitar nenhum

comando, a própria IDE cuida disso.
 Introdução ao Java – Fundamentos básicos - 10

1.3. Variáveis

Uma variável é um contêiner que armazena algo, você pode imaginar como
sendo uma gaveta também e que ela possui um espaço ou tamanho para armazenar
algo e pode ter seu conteúdo alterado com o tempo. A variável em Java deve ter um
nome e um tipo obrigatoriamente. Isso é importante, pois é um recurso que impede
que você insira um valor literal (um texto, por exemplo) dentro de uma variável que
deve armazenar um número inteiro.

Como deve ser o nome de uma variável?

As variáveis devem ter nomes iniciados por caracteres alfabéticos, ou $ ou _ e

podem ser compostas por números e símbolos. Exemplos de nomes de variáveis
válidas: diametro, D, Nome100, _diametro, $diametro, valorTotal, VALORTOTAL,
valor_total, valor$_total. Não pode existir espaço entre os nomes em uma variável. A
linguagem Java é case sensitive, então a variável VALOTOTAL e valorTotal são nomes
diferentes. Exemplos de identifcadores inválidos: :valorTotal, -valorTotal,
valorTotal#, .valorTotal, 7valorTotal.
 Introdução ao Java – Fundamentos básicos - 11

É importante deixar claro que existem palavras reservadas que não podem ser
usadas como identifcadores de variáveis. Veja as palavras reservadas na imagem
abaixo:

Existe uma convenção Java que diz que nomes de variáveis devem:

• usar letras minúsculas;

• se constituído de uma única letra sugere-se a inicial de seus tipos;
• caso sejam compostos de várias palavras, a primeira inicial deve ser
minúscula e as demais iniciais maiúsculas;
• o uso de dígitos é livre;
• não é recomendável o uso do cifrão $ ou sublinhado _

Exemplos: i, f, valor, valorTotal, valorTotalCompra, valor100Desconto.

1.3.1. Tipos primitivos

Existem dois tipos de variáveis em Java: as primitivas e as variáveis de
referência. As variáveis primitivas armazenam valores básicos (bits simples), que
podem ser caracteres, números inteiros, decimais, lógicos (verdadeiro ou falso) etc.
São tipos primitivos em Java: char, boolean, byte, short, int, long, double, foat.
 Introdução ao Java – Fundamentos básicos - 12

Uma variável do tipo char armazena caracteres de tamanho até 16 bits (2

bytes) no formato Unicode UTF-16. Podem assumir caracteres entre '\u0000' a '\uff'
e valores numéricos entre 0 a 65535. Este intervalo grande para o char permite
representar caracteres em várias línguas diferentes.

Uma variável do tipo boolean representa apenas 1 bit de informação (0

ou 1). Podem assumir apenas os valores true ou false.

As variáveis dos tipos byte, short, int, long, double, foat representam
valores numéricos.

Os tipos numéricos inteiros são: byte, short, int e long.

Tipo Tamanho em Tamanho em Intervalo Intervalo

bits bytes mínimo Máximo
byte 8 1 -27 27 - 1
short 16 2 -215 215 - 1
int 32 4 -231 231 - 1
long 64 8 -263 263 - 1

Os tipos numéricos reais (ponto futuante) são: foat e double.

Tipo Tamanho em Tamanho em Intervalo Intervalo

bits bytes mínimo Máximo
foat 32 4 Positivos: Positivos:
+1.4013E-45 +3.4028E+38
Negativos: Negativos:
-3.4028E+38 -1.4013E-45
double 64 8 Positivos: Positivos:
+4.9407E-324 +1.7977E+308
Negativos: Negativos:
-1.7977E+308 -4.9407E-324

Obs.: O intervalo para números reais são bem complicados de determinar.

Podem assumir valores de ponto futuante com formato defnido pela especifcação
IEEE 754.
 Introdução ao Java – Fundamentos básicos - 13

Observe o código TiposPrimitivos.java abaixo que pode ser obtido no

Moodle:
 Introdução ao Java – Fundamentos básicos - 14

Ao executar o código acima, você verá que, mesmo que se atribua um

número qualquer a uma variável do tipo char, ela será tratada pelo método
println() como um caractere, não como um número. Também verá que
uma letra "F" acompanha o valor atribuído à variável floatNumero e que a
l e t r a "L" acompanha o valor atribuído às variáveis longMinimo e
longMaximo.

Essas letras são sufxos de literais. Elas indicam o tipo do valor que você
está passando para a variável.

1.3.2. Variáveis literais

Valores inteiros são tratados como int e ponto futuante como double. Os
outros tipos devem usar sufxos ou prefxos predefnidos:

Tipo Sufxo Prefxo Exemplo

long L 12345678L
foat f 0.350f
hexadecimal 0x ou 0X 0x75DA

1.3.3. Variáveis de referência

As variáveis de referência são usadas para se referir (ou acessar) um objeto,
isto é, guarda o local onde está o objeto.

1.3.4. Variáveis de instância

Cada objeto tem suas próprias cópias das variáveis de instância. Isso signifca
que se tivermos dois objetos Caixa, cada um deles tem sua própria cópia das
variáveis “largura”, “altura” e “profundidade”. Alterações nas variáveis de instância
de um objeto não têm efeito sobre as variáveis de instância de outro objeto.
 Introdução ao Java – Fundamentos básicos - 15

O programa abaixo ilustra esse fato. Ele declara dois objetos da classe
“Caixa”.

Baixe o código-fonte CaixaDemo2.java acima no Moodle, compile e execute.

A saída de “CaixaDemo2.java” é a seguinte: Volume de caixa1 = 1000.0 e Volume de
caixa2 = 3750.0 . É possível perceber que os dados defnidos para “caixa1” são
completamente independentes dos dados defnidos para “caixa2”.
 Introdução ao Java – Fundamentos básicos - 16

1.4. Métodos

Dissemos, anteriormente, que as classes geralmente consistem em duas

coisas: variáveis de instância e métodos. O assunto métodos é muito extenso, porque
é deles que o Java obtém muito de seu poder e fexibilidade. Por isso, em diferentes
partes deste curso, falaremos sobre diversos aspectos dos métodos.

Nesse momento, você precisa entender alguns fundamentos dos métodos,

para que possa começar a acrescentar métodos a suas classes.

Esta é a forma geral de um método:

tipo nomeDoMetodo( lista-de-parâmetros )

{
// Corpo do método.
}

“tipo” especifca o tipo de dados retornado pelo método. Pode ser qualquer
tipo válido, inclusive os tipos de classes criadas pelo programador. Se um método não
retorna nenhum valor, seu valor retornado deve ser declarado como sendo “void”.

O nome do método, o qual é especifcado por “nomeDoMetodo”, pode ser

qualquer identifcador legal, a não ser aqueles já usados por outros itens dentro do
escopo atual.

A “lista-de-parâmetros” é uma sequência de pares compostos de um tipo e um

identifcador, separados por vírgulas. Os parâmetros são, essencialmente, variáveis
que recebem o valor dos argumentos passados para o método quando ele é chamado.

Se o método não tem parâmetros, os parênteses deverão estar vazios.

Métodos que retornam um tipo que não seja “void” retornam um valor para a rotina
que os chama, usando a seguinte forma do comando “return”:

return valor;

onde “valor” é o valor retornado.

 Introdução ao Java – Fundamentos básicos - 17

Raramente criamos uma classe como “Caixa”, que contém somente dados,
embora isso seja perfeitamente legal em Java. Na prática, geralmente usamos
métodos para acessar as variáveis de instância defnidas pela classe.

São os métodos que defnem a interface da maioria das classes. Isso permite
que o implementador da classe oculte o layout interno das estruturas de dados da
classe, por trás das abstrações de métodos. Isso é muito mais seguro e elegante.

Além de defnir métodos que proporcionam acesso aos dados, também

podemos defnir métodos que são usados internamente pela própria classe. Vamos
começar acrescentando um método à classe “Caixa”.

Observe novamente o programa “CaixaDemo.java”. Dentro da flosofa da

orientação a objetos, é muito mais lógico que o cálculo do volume da caixa seja feito
pela própria classe “Caixa”, e não pela classe “CaixaDemo”. Como o volume de uma
caixa depende de suas dimensões, faz sentido deixar que a classe “Caixa” o calcule.
 Introdução ao Java – Fundamentos básicos - 18

Vamos fazer isso, acrescentando um método à classe “Caixa”, conforme

mostra o exemplo abaixo em um código chamado CaixaDemo3.java que pode ser
baixado no Moodle:
 Introdução ao Java – Fundamentos básicos - 19

Este programa gera a seguinte saída:

Volume = 1000.0
Volume = 1536.0

Observe as seguintes linhas:

caixa1.volume();
caixa2.volume();

A linha

caixa1.volume();

invoca o método “volume()” para o objeto “caixa1”. Isto é, ela chama

“volume()” em relação ao objeto “caixa1”, usando o nome do objeto seguido

pelo operador “ponto”. Portanto, a chamada caixa1.volume() exibe o volume da caixa
defnida por “caixa1”. Da mesma forma, a chamada caixa2.volume(); exibe o volume
da caixa defnida por “caixa2”.

Cada vez que “volume()” é invocado, ele exibe o volume da caixa especifcada.

Vamos estudar com mais detalhes o que acontece quando um método é

chamado. Quando caixa1.volume() é executado, o sistema runtime de Java transfere o
controle para o código defnido dentro de “volume()”. Depois que os comandos que
estão dentro de “volume()” são executados, o controle volta para a rotina chamadora,
e a execução é retomada na linha de código que se segue à chamada.

Podemos dizer que o método é a forma usada por Java para implementar sub-
rotinas. Há uma coisa muito importante a se observar dentro do método “volume()”:
as variáveis de instância “largura”, “altura” e “profundidade” são referenciadas
diretamente, sem necessidade de precedê-las com o nome do objeto nem o operador
“ponto”.
 Introdução ao Java – Fundamentos básicos - 20

Quando um método utiliza uma variável de instância que é defnida por sua
classe, ele faz isso diretamente, sem referência explícita a um objeto e sem usar o
operador “ponto”.

Não é difícil entender esse fato. Um método é sempre invocado em relação a

um objeto de uma determinada classe, e sempre que isso acontece o objeto passa a
ser reconhecido. Assim, dentro de um método, não há necessidade de especifcar o
objeto uma segunda vez.

Isso signifca que as variáveis “largura”, “altura” e “profundidade” que

aparecem dentro de “volume()” referem-se implicitamente às cópias dessas variáveis
encontradas dentro do objeto que invoca “volume()”.

Resumindo:

• Quando uma variável de instância é acessada por um código que não faz
parte da classe na qual essa variável de instância é defnida, isso precisa ser feito
através de um objeto, usando o operador “ponto”.

• Quando uma variável de instância é acessada por um código que faz parte
da mesma classe que a variável de instância, essa variável pode ser referenciada
diretamente. O mesmo se aplica aos métodos.

1.4.1. Retorno de um método

Vimos anteriormente que o método “volume()” calcula o volume de uma caixa

no seu devido lugar, que é dentro da classe Caixa. Porém, isso pode ser
implementado de uma forma melhor. Por exemplo, se outra parte do programa
precisasse saber o volume de uma caixa, e não exibir seu valor? Uma forma melhor
de implementar “volume()” é fazer com que esse método calcule o volume de uma
caixa e retorne o resultado para a rotina que o chama. Baixe o código
CaixaDemo4.java no Moodle.
Introdução ao Java – Fundamentos básicos - 21
 Introdução ao Java – Fundamentos básicos - 22

Nas linhas:

volumeVar = caixa1.volume();
volumeVar = caixa2.volume();

quando “volume()” é chamado, ele é colocado no lado direito de um comando

de atribuição. Do lado esquerdo fca a variável, neste caso “volumeVar”, que receberá
o valor retornado por “volume()”.

Por isso, depois da linha volumeVar = caixa1.volume(); o valor 1000.0,

correspondente ao volume de “caixa1”, é armazenado em “volumeVar”.

Da mesma forma, depois da linha volumeVar = caixa2.volume(); “volumeVar”

contém o valor 1536.0, correspondente ao volume de “caixa2”.

Ainda com relação aos valores retornados por um método, dois aspectos
importantes devem ser lembrados:

• O tipo do dado retornado por um método deve ser compatível com o tipo
retornado especifcado para o método. Por exemplo, se o tipo especifcado para um
método for "boolean", ele não pode retornar um "int".

• A variável que recebe o valor retornado por um método, como “volumeVar”

no exemplo acima, também deve ser compatível com o tipo retornado especifcado
para o método.

Finalmente, observe que “CaixaDemo4.java” poderia ser reescrito de forma

um pouco mais efciente. Na verdade, a variável “volumeVar” é desnecessária. A
chamada a “volume()” poderia ter sido usada dentro da própria chamada a
“println()”, conforme mostrado abaixo:

System.out.println( "Volume de caixa1 = " + caixa1.volume() );

Dessa forma, quando “println()” for executado, “caixa1.volume()” será

chamado automaticamente e seu valor será passado para “println()”.
 Introdução ao Java – Fundamentos básicos - 23

1.4.2. Métodos com parâmetros

Muitos métodos utilizam parâmetros para realizar suas tarefas. Os parâmetros

permitem que um método seja mais genérico, ou seja, um método com parâmetros
pode operar sobre diferentes valores de dados e ser usado em diversas situações.

Por exemplo, observe o método abaixo que retorna o quadrado de 2:

int quadrado() {
return 2 * 2;
} // fm do método quadrado()

Embora esse método retorne de fato o valor de 2 ao quadrado, seu uso é muito
limitado. Contudo, se modifcarmos o método de maneira que ele receba um
parâmetro, conforme mostrado a seguir, é possível fazer com que “quadrado()” seja
muito mais útil.

int quadrado( int i ) {

return i * i;
} // fm de método quadrado()

Agora, “quadrado()” retorna o quadrado de qualquer valor para o qual ele seja
chamado. Isto é, “quadrado()” é agora um método de uso geral, capaz de computar o
quadrado de qualquer valor inteiro, e não apenas de 2, conforme mostram as linhas
abaixo.

int x, y;
x = quadrado(7); // x é igual a 49.
x = quadrado(9); // x é igual a 81.
y = 10;
x = quadrado(y); // x é igual a 100.

Na primeira chamada a “quadrado()”, o valor 7 é passado para o parâmetro

“i”. Na segunda chamada, “i” recebe o valor 9. A terceira chamada passa o valor de
“y”, que no caso é 10.
 Introdução ao Java – Fundamentos básicos - 24

Como mostram esses exemplos, “quadrado()” é capaz de retornar o quadrado

de qualquer valor que lhe é passado.

É importante esclarecer o signifcado dos termos parâmetro e argumento. Um

parâmetro é uma variável defnida por um método, e que recebe um valor quando o
método é chamado. Por exemplo, em “quadrado()”, “i” é um parâmetro.

Um argumento é um valor passado para um método quando ele é invocado.

Por exemplo, “quadrado(10)” passa 10 como argumento. Dentro de “quadrado()”, o
parâmetro “i” recebe esse valor.

Vamos aplicar esse novo conceito de métodos parametrizados à classe

“Caixa”. Nos exemplos anteriores, as dimensões de cada caixa precisavam ser
defnidas separadamente com o uso de uma sequência de comandos:

caixa1.largura = 5;
caixa1.altura = 10;
caixa1.profundidade = 20;

Embora esse código funcione, ele é trabalhoso de se escrever e sujeito a erros.

Por exemplo, o programador pode facilmente esquecer de defnir uma dimensão.
Além disso, em programas Java bem projetados, as variáveis de instância devem ser
acessadas somente através de métodos defnidos em sua classe. Assim, digamos, em
uma nova versão do programa, podemos alterar o comportamento de um método.

Porém, não poderíamos alterar o comportamento de uma variável de instância

exposta, sob pena de comprometer o funcionamento de todo o programa. Portanto,
um enfoque melhor para defnir as dimensões de uma caixa é criar um método que
recebe a dimensão da caixa em seus parâmetros e ajusta cada variável de instância
apropriadamente.
 Introdução ao Java – Fundamentos básicos - 25

Esse conceito é implementado no seguinte programa CaixaDemo5.java que

pode ser baixo no Moodle:
 Introdução ao Java – Fundamentos básicos - 26

Nas linhas:

caixa1.defneDim(5, 10, 20);

caixa2.defneDim(8, 12, 16);

o método “defneDim()” é usado para defnir as dimensões de cada caixa.

Assim, quando a linha:

caixa1.defneDim(5, 10, 20);

é executada:

• o valor 5 é copiado para o parâmetro “larg”

• o valor 10 é copiado para o parâmetro “alt”

• o valor 20 é copiado para o parâmetro “prof”

Dentro do método “defneDim()”, os valores de “larg”, “alt” e “prof” são

atribuídos a “largura”, “altura” e “profundidade”, respectivamente.
 Introdução ao Java – Fundamentos básicos - 27

1.5. Controle de fuxo: if / else / while / for / switch

Veremos neste tópico o uso das instruções de controle de fuxo no Java.

1.5.1. if
A diretiva if permite a tomada de decisão baseada numa condição. Estrutura
do if:

if ( < cond > )

corpo_true
else
corpo_false

• cond – expressão lógica obrigatória que determina se o corpo será

executado ou não;
• corpo_true – diretiva simples ou bloco executado quando a condição
resultar true;
• corpo_false – diretiva simples ou bloco executado quando a condição
resultar false
• a cláusula “else” e seu corpo são opcionais;
• sem “else” permite executar ou não uma diretiva baseada na condição;
• com “else” permite executar uma entre duas diretivas conforme a condição.
 Introdução ao Java – Fundamentos básicos - 28

Exemplo de código com if, baixe o código DiretIf.java no Moodle:

A seguir temos as expressões válidas com if :

• Só podem aceitar valores booleanos

• Em java 0 = = false e 1 = = true não é valido.

int trueInt =1;

int falseInt =0;
if ( truInt == true ) {} // invalido
if ( trueInt == 1 ) {} // valido

A única variável que pode ser atribuída na instrução if é booleana.

boolean resultado = true

if ( resultado = false ) {} // valido
int idade
// invalido
if ( idade = 3 ) {}
 Introdução ao Java – Fundamentos básicos - 29

1.5.2. switch

A diretiva switch permite seleção condicional múltipla. É a maneira de simular

varias instruções if .

switch ( <expr_ord> ) {
[ case const0 :
[ diretivas; ]]
[ case const1 :
[ diretivas; ]]
[ default :
[ diretivas; ]]
}

• expr_ord – Expressão ordinal obrigatória que identifca a diretiva ou bloco a

ser executado;
• constN – constante literal que identifca uma diretiva ou bloco;
• default – cláusula que defne a diretiva ou bloco a ser executado quando o
resultado não corresponde aos cases existentes.
 Introdução ao Java – Fundamentos básicos - 30

Exemplo do switch:

• O break é opcional porém causa mudança no resultado na remoção dele;

• char, short,byte,int ou enum são permitido no teste switch;
• não é possível compilar se o teste for: long, foat e double;
• O valor do case deve ser constante, ou seja, não pode mudar;

fnal int a=1; //valido

fnal int b;//invalido
b = 2;

• Se uma variável for menor que o tipo int é convertido desde, que siga a regra
do tipo;

byte g =2;
switch(g){
case 23://valido
case 128: // invalido muito grande para um byte.
 Introdução ao Java – Fundamentos básicos - 31

1.5.3. break
O importante é que o switch funciona de cima para baixo, e quando um case
verdadeiro é encontrado tudo abaixo será executado, isso quando não temos o break
para dar um stop no processo. Baixe o código sw1.java no Moodle para teste:

• quando o programa encontra a palavra-chave break ele sai do Switch.

• O processo sem o break é chamado de “passagem completa”.
• O uso do break é quando você quer que apenas aquela instrução que for
satisfatória seja executada.
• Após a saída do switch o que estiver fora será executada normalmente
 Introdução ao Java – Fundamentos básicos - 32

1.5.4. default

• é se nenhuma instrução case for satisfatória

• A instrução default pode aparecer em qualquer lugar e segue com a mesma
regra do break ou sem o break.
• O default funciona com passagem completa por isso é recomendável o uso no
fnal do bloco do switch.

Exemplo, baixe o código sw2.java no Moodle:

No exemplo acima o switch observe o tamanho do objeto string que possui 3

caracteres e compara com os cases, o método que retorna o tamanho de uma String
é o length() que já vem como padrão na API do Java.
 Introdução ao Java – Fundamentos básicos - 33

1.5.5. for
A instrução for é usada para percorrer conjunto de dados, que pode ser um
array, uma lista, etc. A partir do Java 5, o for ganhou um novo apelido : “for básico” o
motivo foi que nasceu um novo tipo de for, o chamado de for aprimorado, tem o
mesmo objetivo, porém melhora a legibilidade quando precisamos percorrer todo o
conjunto sem se preocupar em saber o tamanho dele. Veremos mais na frente o for
aprimorado.

Algumas características:

• Mais fexível que o for aprimorado;

• é possível colocar mais de uma variável;
• Só pode existir uma expressão TESTE;

for ( int x=0; (x>5) , (y<2); x++) {} //invalido

Outro exemplo, baixe o código DiretFor.java no Moodle:

 Introdução ao Java – Fundamentos básicos - 34

1.5.6. For avançado

O for avançado otimiza o processamento de arranjos e coleções.

for ( [TipoElem] <var> : <expr> )

corpo

• TipoElem – Tipo do elemento do arranjo ou coleção;

• var – Variável que representa um elemento do arranjo ou coleção no corpo
da diretiva;
• expr – Arranjo ou instância da interface Iterable (coleção), inicializada
externamente ao for.
• corpo – Diretiva simples ou bloco cuja execução será controlada pela
condição.
• Simplifca a tarefa de fazer um loop através de um array ou conjunto. Possui
apenas dois componentes:

Exemplo, baixe o código ForEach.java no Moodle:

 Introdução ao Java – Fundamentos básicos - 35

1.5.7. while
A instrução while serve para testar uma condição enquanto ela for verdadeira,
a diferença é que sempre que for verdadeira, o que está no bloco do while é
executado. Muito cuidado para não criar loops infnitos aqui.

Exemplo, baixe o código DiretWhile.java no Moodle:

 Introdução ao Java – Fundamentos básicos - 36

1.5.8. do / while

Diretiva de repetição condicional, cuja condição é avaliada depois da execução

do corpo da diretiva.

do {
corpo;
} while ( <cond> );

• cond – Expressão lógica obrigatória que usualmente envolve a variável de

controle (defnida externamente) e determina se o corpo será executado
outra vez ou não;
• corpo – Diretiva simples ou bloco cuja execução será controlada pela
condição;

Exemplo, baixe o código DiretDoWhile.java no Moodle:

 Introdução ao Java – Fundamentos básicos - 37

1.6. Construtores

Não é prático inicializar todas as variáveis de uma classe cada vez que uma
instância é criada mesmo que seja por meio de métodos como o “defneDim()” do
exemplo CaixaDemo5.java. Seria mais simples e prático se toda a inicialização fosse
feita automaticamente no momento da criação do objeto. Como a necessidade de
inicialização é muito comum, o Java permite que os objetos inicializem a si mesmos
quando são criados. Essa inicialização automática é executada através do uso de um
método construtor.

Um construtor é um método que inicializa um objeto imediatamente, no

momento de sua criação. Ele tem o mesmo nome da classe na qual reside e é
sintaticamente similar a qualquer outro método. Uma vez defnido, o construtor é, de
forma automática, imediatamente chamado após a criação do objeto, antes que o
operador new complete seu trabalho.

Um aspecto diferente do construtor é que ele não tem tipo retornado, nem
mesmo void. Isso acontece porque o tipo retornado pelo construtor de uma classe é o
tipo da própria classe.

A missão do construtor é inicializar o estado interno de um objeto, de modo

que após sua criação, esse objeto esteja totalmente inicializado e pronto para uso.

O exemplo da classe “Caixa” da lição anterior pode ser reescrito, de modo que
as dimensões da caixa sejam automaticamente inicializadas quando o objeto for
construído. Isso é feito com o uso de um construtor no lugar do método
“defneDim()”. Nessa primeira versão, o construtor simplesmente ajusta todas as
dimensões da caixa para um mesmo valor.
 Introdução ao Java – Fundamentos básicos - 38

Esta versão CaixaDemo6.java pode ser baixada no Moodle e é mostrada

abaixo:
 Introdução ao Java – Fundamentos básicos - 39

Ao ser executado, este programa gera o resultado abaixo:

Construindo objeto caixa...

Construindo objeto caixa...
Volume de caixa1 = 8000.0
Volume de caixa2 = 8000.0

Nas linhas :

Caixa caixa1 = new Caixa();

Caixa caixa2 = new Caixa();

“caixa1” e “caixa2” são inicializados pelo construtor “Caixa()”, no momento

em que são criados.

Dentro do método construtor, vemos que ele atribui a todas as caixas as

mesmas dimensões, 20 por 20 por 20. Por isso, tanto “caixa1” quanto “caixa2” terão
o mesmo volume. O comando “println()”, contido dentro do construtor “Caixa()”,
serve apenas para ilustrar o momento em que o construtor é executado.
Normalmente, o construtor apenas inicializa o objeto, sem exibir nenhuma
mensagem.

À luz de nosso novo conhecimento sobre os construtores, vamos fazer uma

rápida revisão do operador new. Como sabemos, quando alocamos um objeto,
devemos usar a seguinte forma geral:

classeVar = new nomeDaClasse();

 Introdução ao Java – Fundamentos básicos - 40

Agora os parênteses ( ) que aparecem após o nome da classe passam a fazer

sentido. Na verdade, o que está acontecendo é que o construtor da classe está sendo
chamado. Assim, na linha:

Caixa caixa1 = new Caixa();

“new Caixa()” representa uma chamada ao construtor “Caixa()”.

Se o programador não defnir explicitamente um construtor para uma

determinada classe, Java cria um construtor default. É por isso que a linha de código
acima funcionava nas versões anteriores de “Caixa”, quando ainda não tínhamos
defnido o construtor.

O construtor default defnido pelo Java automaticamente inicializa todas as

variáveis de instância para zero. Muitas vezes, esse construtor é sufciente para
classes simples. As classes mais sofsticadas geralmente precisam de construtores
defnidos explicitamente.

Se um construtor for defnido pelo programador, o construtor default não será

mais utilizado.
 Introdução ao Java – Fundamentos básicos - 41

1.7. Operadores e expressões

Defnição: Operadores são símbolos que indicam as operações de atribuição,

aritméticas, bit a bit, relacionais e lógicas.

1.7.1. Operador de atribuição

= Atribui o valor de um elemento ou resultado de uma expressão a uma
variável.

Operadores de atribuição compostos

• += Soma e atribui
• -= Subtrai e atribui
• *= Multiplica e atribui
• /= Divide e atribui

1.7.2. Operadores aritméticos

• + Adição
• - Subtração
• * Multiplicação
• / Divisão
• % Resto da divisão inteira
 Introdução ao Java – Fundamentos básicos - 42

1.7.3. Operadores de incremento e decremento

• ++ Incremento unitário (adiciona uma unidade)

Exemplo:

int a = 1, b;
b = a++; // b recebe 1, a contém 2

int a = 1, b;
b = ++a; // b recebe 2, a contém 2

• -- Decremento unitário (subtrai uma unidade)

1.7.4. Operadores lógicos

• && E lógico (and)

• || Ou lógico (or)
• ! negação (not)
 Introdução ao Java – Fundamentos básicos - 43

Exemplo, baixe o código OperLogic.java no Moodle:

1.7.5. Operadores relacionais

• == Igualdade
• != Diferença
• > Maior que
• < Menor que
• >= Maior ou igual
• <= Menor ou igual
 Introdução ao Java – Fundamentos básicos - 44

1.8. Referências Bibliográfcas

• Java 6 – Guia de Consulta Rápida – Peter Jandl Jr. Editora Novatec

• Certifcação Sun para programador Java 6 – Guia de Estudo – Kathy Sierra,
Bert Bates – Editora AltaBooks
• http://pt.wikinourau.org/bin/view/GrupoJava/TutorialJAV711