2. Fundamentos da Linguagem Java
•
•
•
•
Como vimos, um programa Java é constituído por um conjunto de
classes. Cada classe é constituída por um conjunto de campos (para
armazenar valores) e por um conjunto de métodos (que
implementam as operações possíveis sobre os valores dos campos da
classe).
Os campos de uma classe são variáveis de tipos primitivos ou objetos
de classes já existentes (pertencentes à Java API) ou de novas
classes definidas pelo programador.
Os métodos são melhor implementados quando se utilizam técnicas
de programação estruturada.
Elementos de um programa Java:
Num programa Java podem existir:
Identificadores (Exemplo, ano, exibir)
public class Exemplo
Declarações (int ano)
{
Atribuições (ano = 2007)
private int ano;
Controle de visibilidade (public, private)
public void exibir()
Chamadas de métodos (println...)
{
...
ano = 2009;
System.out.println("FEG/UNESP-" + ano);
}
}
35
© ELFS
2. Fundamentos da Linguagem Java
Elementos de um Programa Java
• Declarações: Uma ou mais linhas de código (normalmente, não
executável) terminadas por ponto-e-vírgula. As declarações são
usadas para estabelecer os atributos de identificadores usados no
programa. Exemplos:
int i;
int j = 10;
Primeira p;
Segunda s = new Segunda();
• Instruções: Linhas de código executável terminadas por ponto-evírgula. As instruções compreendem: comandos de atribuição e
chamadas de métodos. Exemplos:
i = 0;
Valor = v1 + v2 + v3 + v4 + v5;
p = new Primeira();
p.saudar();
JOptionPane.showMessageDialog(null,
"A soma é " + soma,
"Resultado", JOptionPane.PLAIN_MESSAGE);
© ELFS
36
2. Fundamentos da Linguagem Java
• Bloco: Um conjunto de declarações e instruções delimitadas por
chaves. Exemplo:
{
int Valor1,Valor2;
Valor1 = v1 + v2 + v3 + v4 + v5;
Valor2 = v2 + v3;
}
• Estruturas de controle: Controlam como as instruções de um bloco
devem ser executadas. Exemplos:
if (i < 10)
{
i = i + 1;
System.out.println("Valor de i = " + i);
}
Estrutura de seleção
Estrutura de repetição
for (int i = 0; i < 10; i++)
{
int j = i * 2;
t.incrementar(j);
}
37
© ELFS
2. Fundamentos da Linguagem Java
• Palavras reservadas: Palavras de uso reservado (os identificadores de
um programa devem ser diferentes das palavras-chave. Lembrar que
Java faz distinção entre letras maiúsculas e minúsculas). Em Java
existem apenas 49 palavras reservadas:
abstract
continue
goto
package
synchronized
assert
default
if
private
this
boolean
do
implements
protected
THROW
break
double
import
public
throws
byte
else
instanceof
return
transient
case
extends
int
short
try
catch
final
interface
static
void
char
finally
long
strictfp
volatile
class
float
native
super
while
const
for
new
switch
• As palavras const e goto são apenas reservadas, mas não são
usadas.
© ELFS
38
2. Fundamentos da Linguagem Java
• Tipos primitivos: Em Java existem 8 tipos primitivos separados em
quatro categorias:
Categoria
Tipos primitivos
Lógico
boolean
Textual
char
Inteiro
byte, short, int, long
Ponto flutuante
double, float
• Para cada tipo primitivo há uma classe wrapper correspondente no
pacote java.lang. Por exemplo, Integer (para o tipo int) e Double
(para o tipo double).
• Notar que os nomes de classes sempre começam com uma letra
maiúscula. Essas classes fornecem métodos para processamento dos
valores do tipo primitivo (por exemplo, para converter um String em
um valor do tipo int ou um valor do tipo int em um String).
39
© ELFS
2. Fundamentos da Linguagem Java
O tipo boolean
• Dois valores apenas para o tipo boolean: true e false.
• true e false são dois valores literais já definidos na linguagem Java
(como as palavras reservadas).
• Diferentemente de C (onde não existe o tipo boolean) valores inteiros
(como 0 e 1) não podem ser usados como valores lógicos.
• Não existe conversão entre boolean e int.
boolean b = false;
boolean deNovo;
deNovo = (x < 10);
• Operadores lógicos e booleanos
Operador
© ELFS
Sejam:
int x = 1;
int y = 4;
Nome
&&
conjunção lógica
&
conjunção booleana
||
disjunção lógica
|
disjunção booleana
^
disjunção lógica exclusiva
!
negação lógica
(x ==
(x ==
(x ==
(x ==
(x ==
! ( y
1)
5)
1)
1)
1)
>=
&& (y >= 5)
& (y >= 1)
|| (y >= 5)
| (y >= 5)
^ (y <= 5)
5 )
false
false
true
true
false
true
40
2. Fundamentos da Linguagem Java
•
O operador && tem uma precedência mais alta que o operador ||.
Ambos operadores se associam da esquerda para a direita.
•
Uma expressão contendo operadores && ou || é avaliada somente
até que a verdade ou falsidade seja detectada. Esse recurso de
desempenho para avaliação de expressões lógicas é chamado de
avaliação em curto-circuito.
•
Os operadores booleanos & e | trabalham identicamente aos
operadores lógicos && e ||, mas os operadores booleanos sempre
avaliam seus dois operandos, isto é, não há avaliação em curtocircuito, o que pode provocar efeitos colaterais. Por exemplo:
double x[] = {1,2,3,4,5};
int i;
...
if ((i < 5) & (x[i] > 1.5))
Aqui pode ocorrer um erro, se
a expressão (i < 5) for false.
...
if ((i < 5) && (x[i] > 1.5))
Aqui não.
41
© ELFS
2. Fundamentos da Linguagem Java
Outros operadores
•
Operadores aritméticos
Precedência
Operador
1
+
Adição
Operação
Exemplo
7+2
Resultado
9
1
-
Subtração
7-2
5
2
*
Multiplicação
7*2
14
2
/
Divisão
7/2
3 (int) ou 3.5 (float)
2
%
Resto
7%2
1
Expressões
entre
parênteses
têm a mais alta
precedência
(são executadas
primeiro).
Numa expressão algébrica, operações de mesma precedência são
executadas na ordem em que aparecem, da esquerda para a direita.
•
Operadores de igualdade
Operador
© ELFS
Exemplo
Resultado
==
é igual a
Operação
7 == 2
falso
!=
não é igual a
7 != 2
verdadeiro
Um erro muito comum é
utilizar = como operador de
igualdade. Lembrar que = é o
operador de atribuição.
42
2. Fundamentos da Linguagem Java
•
•
Operadores relacionais
Operador
Operação
Exemplo
Resultado
>
é maior que
7>2
verdadeiro
<
é menor que
7<2
falso
>=
é maior que ou igual a
7 >= 2
verdadeiro
<=
é menor que ou igual a
7 <= 2
falso
Note:
Não pode haver
espaço entre os
símbolos dos
operadores:
==
!=
>=
<=
Associatividade dos operadores
Operadores
( )
Tipo
Associatividade
parênteses
da esquerda para a direita
multiplicativo
da esquerda para a direita
aditivo
da esquerda para a direita
< <= > >=
relacional
da esquerda para a direita
== !=
igualdade
da esquerda para a direita
=
atribuição
da direita para a esquerda
* / %
+ -
Note que o operador de
atribuição é diferente dos
demais. Numa atribuição:
v = e;
primeiro avalia-se a expressão
que está à direita do operador
(e). Em seguida, o valor da
expressão é atribuído à
variável que aparece à
esquerda do operador (v).
43
© ELFS
2. Fundamentos da Linguagem Java
•
•
© ELFS
Operadores de atribuição
Operador
Atribuição
Equivalente
Valor de x
+=
x += 2
x = x + 2
7
-=
x -= 2
x = x - 2
3
*=
x *= 2
x = x * 2
10
/=
x /= 2
x = x / 2
2 ou 2.5
%=
x %= 2
x = x % 2
1
Para o exemplo,
considere x = 5
antes de cada
linha da tabela
Operadores de incremento e de decremento
Operador
Nome
Exemplo
Significado
++
pré-incremento
++x
Incrementa x de 1 e então usa o novo
valor de x na expressão onde x reside.
++
pós-incremento
x++
Usa o valor de x na expressão onde x
reside e depois incrementa x de 1.
--
pré-decremento
--x
Decrementa x de 1 e então usa o novo
valor de x na expressão onde x reside.
--
pós-decremento
x--
Usa o valor de x na expressão onde x
reside e depois decrementa x de 1.
44
2. Fundamentos da Linguagem Java
O tipo char e a classe String
• Um valor do tipo char representa um caractere Unicode de 16 bits e
deve ser escrito entre apóstrofos. Por exemplo: 'a'.
• String não é um tipo primitivo e sim uma classe. Objetos dessa
classe representam textos, ou seja, sequências de caracteres
Unicode. Strings devem ser escritos entre aspas. Exemplo:
"Linguagem Java".
• Caracteres de controle \n (nova linha), \t (tabulação), \r (retorno ao
início da linha), \\ (barra invertida) e \” (aspas) podem ser usados
como parte de strings.
Exemplos:
• char x = 'c';
a letra c
• char nl = '\n';
caractere de 'nova linha'
• char fi = '\u03A6';
a letra Ф
• String nome = "Programação de Computadores II";
• String sigla = "PC2";
Observe que para a classe String
não é necessário utilizar new para
criar um novo objeto da classe.
45
© ELFS
2. Fundamentos da Linguagem Java
Os tipos byte, short, int e long
• A diferença entre os quatro tipos inteiros está no tamanho: byte ocupa
8 bits, short 16 bits, int 32 bits e long 64 bits.
• Os números inteiros podem ser utilizados em três formatos: decimal,
octal e hexadecimal.
• int é o tipo padrão para os inteiros.
Exemplos:
Valor Representa o:
© ELFS
Observação
56
decimal 56
Valor inteiro escrito na notação usual
070
octal 70
Valores iniciados por 0 (zero) representam números
octais. (70)8 = (56)10
0x38
hexadecimal 38
Valores iniciados por 0x (zero) representam números
hexadecimais. (38)16 = (56)10
56L
longo 56
Valores terminados por L ou l representam inteiros long
46
2. Fundamentos da Linguagem Java
Os tipos float e double
• Valores numéricos não inteiros podem ser dos tipos float (32 bits) ou
double (64 bits). A representação de valores de ponto flutuante segue
a norma IEEE-754.
• Valores de ponto flutuante são identificados:
• pela presença de um ponto decimal, ou
• pela presença de um expoente, ou
• pela presença da letra F (ou f) ou da letra D (ou d) ao final.
• double é o tipo padrão para números de ponto flutuante.
Exemplos:
Valor
Observação
2.34
Valor de ponto flutuante escrito na notação usual
0.234E1 Valor de ponto flutuante com expoente positivo
© ELFS
23.4E-1
Valor de ponto flutuante com expoente negativo
2.34F
Valor de ponto flutuante do tipo float
2.34D
Valor de ponto flutuante do tipo double
2.34
Valor de ponto flutuante do tipo double
47
2. Fundamentos da Linguagem Java
Intervalo de valores aceitos pelos tipos primitivos:
Tipo
Bits
boolean
8
char
16
byte
8
Menor valor
Maior valor
false
true
'\u0000'
'\uFFFF'
-128
127
short
16
-32768
32767
int
32
-2147483648
2147483647
long
64
-9223372036854775808
9223372036854775807
float
32
-3.40292347E+38
3.40292347E+38
double
64
-1.79769313486231570E+308
1.79769313486231570E+308
Notar que:
Tipo
Bits
Menor valor
Maior valor
8
-27
27 – 1
short
16
-215
215 – 1
int
32
-231
231 – 1
64
-263
263 - 1
byte
long
© ELFS
48
2. Fundamentos da Linguagem Java
Variáveis de referência (ponteiros)
• Em Java, uma variável pode representar um valor de um dos tipos
primitivos ou um objeto de uma classe (nova ou da API).
• Uma variável que não representa um valor de tipo primitivo é
conhecida como variável de referência (também conhecido como
ponteiro).
Exemplo:
public class MinhaData
{
private int dia;
private int mes;
private int ano;
...
}
public class Teste
{
private MinhaData d;
d = new MinhaData(17,3,2009);
}
© ELFS
Observe que d é uma
variável do tipo
MinhaData, ou seja,
representa um objeto da
classe MinhaData.
Portanto, d é uma variável
de referência (um
ponteiro).
49
2. Fundamentos da Linguagem Java
Construção e inicialização de objetos
• Variáveis (de tipos primitivos ou de referência) são criadas em uma
área de memória da JVM conhecida como Stack (pilha).
• Objetos são criados em uma área de memória da JVM conhecida como
Heap (monte). A criação de um objeto (a ser apontado por uma
variável de referência) requer a utilização do operador new.
• Uma chamada a new Xxx() desencadeia as seguintes ações:
Alocação de memória para a variável de referência em Stack e
inicialização dessa variável com o valor padrão (null);
Execução do construtor para criar um objeto da classe, alocação de
memória (no Heap) para o objeto criado e inicialização de seus
campos (variáveis) com os valores padrão (0, null, etc). Caso o
construtor tenha parâmetros, os valores dos parâmetros são
usados para a inicialização dos campos do objeto criado.
Atribuição do endereço do objeto (no Heap) para a variável de
referência (na Stack), ou seja, a variável de referência aponta para
o objeto criado.
© ELFS
50
2. Fundamentos da Linguagem Java
Exemplo:
MinhaData d = new MinhaData (17, 3, 2009);
d
null
Stack
Heap
Alocação de memória para a variável de referência na Stack e inicialização
dessa variável (ponteiro) com o valor padrão (null).
51
© ELFS
2. Fundamentos da Linguagem Java
Exemplo:
MinhaData d = new MinhaData (17, 3, 2009);
d
null
01
01
1900
Stack
dia
mes
ano
Heap
Alocação de memória para o objeto no Heap e inicialização de seus atributos
(campos) com os valores-padrão. Os valores-padrão para os atributos de uma
classe (caso existam) são estabelecidos na própria classe.
© ELFS
52
2. Fundamentos da Linguagem Java
Exemplo:
MinhaData d = new MinhaData (17, 3, 2009);
d
null
17
3
2009
Stack
dia
mes
ano
Heap
Em seguida, os parâmetros do construtor são usados para inicialização dos
atributos (campos) do objeto criado.
53
© ELFS
2. Fundamentos da Linguagem Java
Exemplo:
MinhaData d = new MinhaData (17, 3, 2009);
d
0xF789
17
3
2009
Stack
dia
mes
ano
Heap
Finalmente, o endereço do objeto criado (no Heap) é atribuído à variável de
referência. Com isso, a variável de referencia passa a apontar para o objeto
criado.
© ELFS
54
2. Fundamentos da Linguagem Java
Coleta de lixo
• Quando um ponteiro se perde (por exemplo, quando ele passa a
apontar para outro objeto ou quando é atribuído o valor null a ele), o
objeto para o qual apontava passa a ser um lixo (pois não haverá mais
como acessar o objeto).
Heap
d
0xF789
17
3
Stack
•
2009
dia
mes
ano
A coleta de lixo é feita automaticamente pela JVM, ou seja, o
programador não tem controle algum sobre esse processo. Em Java,
portanto, não existem primitivas para alocação e desalocação de
memória (como calloc e free, em C).
O coletor de lixo é implementado como um processo que fica
verificando constantemente se existe algum objeto que não é mais
referenciado e, caso exista, libera a memória alocada a esse objeto.
•
55
© ELFS
2. Fundamentos da Linguagem Java
Conversão de tipos
• Uma conversão ocorre ao se atribuir um valor de um tipo a uma
variável de outro tipo.
• Se os tipos forem compatíveis, ou se a variável que recebe o valor for
maior (em bits) do que o valor atribuído, a conversão é automática e
feita no momento da atribuição.
• Do contrário, ou seja, se a variável que recebe o valor é menor (em
bits) do que o valor atribuído, deve haver uma conversão explícita de
tipo (cast) no momento da atribuição.
Exemplos:
long a = 77L;
int b = a;
int c = (int)a;
// OK
// Errado
// OK, mas...
short d = 1, e = 1, f = 1;
d = e + f;
// Erro! Por que?
float g = 3.14; // Erro! Por que?
char
Tamanho dos tipos:
byte
© ELFS
int
long
float
double
short
56
2. Fundamentos da Linguagem Java
Estruturas de Controle
• Para implementar os métodos de uma classe devemos usar a
programação estruturada (vista em Programação de Computadores I).
• Existem três categorias de estruturas de controle:
• sequência
• seleção
• repetição
Sequência
String s = JOptionPane.showInputDialog("s:");
int n = Integer.parseInt(s);
int a = n + 1;
System.out.println("a = " + a);
...
Dentro de um retângulo
existe uma ação (atribuição
ou chamada de método).
57
© ELFS
2. Fundamentos da Linguagem Java
Estruturas de Seleção
if
switch
V
F
V
break
V
break
V
break
F
F
...
if/else
F
V
F
Dentro de um losango existe uma
comparação (expressão do tipo boolean).
© ELFS
58
2. Fundamentos da Linguagem Java
Estruturas de Repetição
do/while
for
while
V
V
F
F
V
F
Observe que:
•
•
•
while executa uma ação zero ou mais vezes.
do...while executa uma ação uma ou mais vezes.
for é uma estrutura de repetição que deve ser usada quando se sabe
exatamente quantas vezes alguma ação deve ser repetida (repetição
com base no valor de um contador).
59
© ELFS
2. Fundamentos da Linguagem Java
Exemplos:
•
A estrutura if
if (expressão booleana)
bloco
if (nota >= 7)
{
System.out.println("Aprovado");
}
if (nota >= 7)
{
System.out.print("Aprovado ");
System.out.println("sem exame final");
}
•
A estrutura if...else
if (expressão booleana)
bloco1
else
bloco2
© ELFS
if (nota >= 7)
{
System.out.println("Aprovado");
}
else
{
System.out.println("Exame final");
}
60
2. Fundamentos da Linguagem Java
•
O operador ? corresponde a um if...else simples.
System.out.println(nota >= 7 ? "Aprovado" : "Exame final");
•
As estruturas if e if...else (como quaisquer outras estruturas) podem
ser combinadas.
if (x > 5)
{
if (y > 5)
{
System.out.println("x e y maiores que 5");
}
}
else
{
System.out.println("x menor ou igual a 5");
}
61
© ELFS
2. Fundamentos da Linguagem Java
•
A estrutura switch corresponde a uma seleção múltipla. Uma seleção
múltipla depende de uma expressão cujo valor deve ser de um dos
seguintes tipos: byte, short, char ou int.
•
Uma estrutura switch substitui várias estruturas if...else combinadas e
pode tornar mais legível o código de um programa.
switch (expressão1)
{
case constante1:
comandos;
break;
case constante2:
comandos;
break;
default:
comandos;
break;
}

© ELFS
Na declaração do switch, expressão1
deve ser avaliada para um valor
compatível com int. A conversão
automática ocorre para os tipos byte,
short ou char.
Expressões que avaliem para um valor
em ponto flutuante ou referências a
classes (mesmo String) não podem ser
utilizadas.
O caso default é opcional e será
executado se nenhum dos casos
anteriores o for.
62
2. Fundamentos da Linguagem Java
•
A estrutura for
for (exp1; exp2; exp3)
bloco
•
for (int i = 1; i < 10; i++)
{
System.out.println("i = " + i);
}
A estrutura while
while (exp)
bloco
•
int i = 1;
while (i < 10)
{
System.out.println("i = " + i);
i++;
}
A estrutura do...while
do
bloco
while (exp);
Atenção para o
ponto-e-vírgula
final.
int i = 1;
do
{
System.out.println("i = " + i);
i++;
}
while (i < 10);
63
© ELFS
2. Fundamentos da Linguagem Java
Exemplo:
• Você investe $300,00 em um fundo financeiro que rende juros de 1%
ao mês. Assumindo que todo o rendimento é deixado em depósito,
calcular e exibir o saldo do fundo no fim de cada mês, para um
período de 12 meses. Utilize a seguinte fórmula: s = d(1 + t)m, onde:
d é o valor inicial investido, t é a taxa de juros mensal, m é o número
de meses e s é o saldo ao final dos m meses.
Juros.java
public class Juros
{
public static void main(String[] args)
{
float taxa = 0.01F;
Fundo f = new Fundo(300);
for (int i = 0; i < 12; i++)
{
f.saldoApos(i+1,taxa);
System.out.printf("Após %2d meses: ",(i+1));
f.mostrar();
}
}
}
© ELFS
64
2. Fundamentos da Linguagem Java
public class Fundo
{
private double inicial;
private double capital;
Fundo.java
Fundo
public Fundo()
− double inicial
− double capital
{
inicial = 0;
+ void saldoApos(int m, float t)
capital = 0;
+ void mostrar()
}
public Fundo(float x)
{
inicial = x;
capital = x;
}
public void saldoApos(int m, float t)
{
capital = capital * Math.pow(1+t,m);
}
public void mostrar()
{
System.out.printf("Capital = %8.2f\n", capital);
}
}
65
© ELFS
2. Fundamentos da Linguagem Java
As instruções break e continue
•
As instruções break e continue alteram o fluxo de controle. A instrução
break, quando executada em uma estrutura while, for, do...while ou
switch, ocasiona a saída imediata dessa estrutura. A execução
continua com a primeira instrução depois da estrutura.
•
A instrução continue, quando executada em uma estrutura while, for
ou do...while, pula as instruções restantes no corpo dessa estrutura e
prossegue com a próxima iteração da repetição. Nas estruturas while
e do...while, a condição de continuação da repetição é avaliada
imediatamente depois da instrução continue ser executada. Na
estrutura for, a expressão de incremento é executada, e então a
condição de continuação é avaliada.
•
As instruções break e continue se aplicam apenas à estrutura na qual
estão contidas.
© ELFS
66
2. Fundamentos da Linguagem Java
Escopo de Variáveis
• Variáveis são declaradas dentro de uma classe. São, portanto, ou
campos da classe ou variáveis de métodos da classe.
• Variáveis de métodos da classe são chamadas variáveis locais (também
conhecidas como variáveis automáticas ou de pilha).
• Variáveis locais devem obrigatoriamente ser inicializadas antes de
serem usadas pela primeira vez no método.
• Parâmetros de métodos (inclusive dos construtores) também são
variáveis locais. Não é necessário inicializá-los pois eles são
inicializados pelo código que faz a chamada ao método.
• As variáveis locais de um método são criadas (na pilha) cada vez que o
método é chamado. Estas variáveis irão existir até que o método
termine sua execução (quando, então, são retiradas da pilha).
• Portanto, variáveis locais têm o escopo do método, ou seja, têm
existência apenas dentro do método. O mesmo nome de variável pode
ser utilizado em métodos diferentes.
67
© ELFS
2. Fundamentos da Linguagem Java
• Variáveis que são campos da classe podem ser:
• variáveis de classe (ou estáticas), ou
• variáveis de objeto (ou dinâmicas).
• Variáveis estáticas são declaradas utilizando-se a palavra reservada
static. Estas variáveis são criadas quando a classe é carregada e
existem enquanto a classe existir (ou seja, enquanto durar a execução
do programa). Pode-se entender as variáveis estáticas como variáveis
globais, disponíveis a todos os objetos da classe. Para variáveis
estáticas públicas, a referência é feita a partir do nome da classe.
• Variáveis dinâmicas são declaradas sem a palavra reservada static.
Variáveis desse tipo são criadas quando um objeto é construído após
uma chamada a new Xxx(). Essas variáveis são inicializadas
automaticamente ao serem criadas (com o valor null). As variáveis
dinâmicas existem enquanto o objeto existir. Cada objeto possui as
suas próprias variáveis dinâmicas. Para variáveis dinâmicas públicas, a
referência é feita a partir do nome do objeto.
© ELFS
68
2. Fundamentos da Linguagem Java
Exemplo 1:
Valor = 86,00 - Conversoes = 1
Valor = 30,00 - Conversoes = 2
Process completed.
69
© ELFS
2. Fundamentos da Linguagem Java
Exemplo 2:
Notar que, como os campos da classe são públicos
(o que não é recomendado), esses campos
podem ser acessados na classe Converter. Note
que conversoes é um campo estático e valor é
um campo dinâmico.
Valor = 86,00 - Conversoes = 1
Valor = 30,00 - Conversoes = 2
Process completed.
© ELFS
70