PC2 Cap2

Prévia do material em texto

16 © ELFS 
Elementos de uma classe Java 
•  Um método é especial: construtor. Para que serve? 
O construtor é usado para construir objetos da classe. 
•  Por que é necessário criar objetos de uma classe? 
Para utilizar os recursos da classe. 
•  Quais são os recursos utilizáveis de uma classe? 
Seus métodos (parte pública da classe). 
− double altura 
− double peso 
+ Pessoa(double, double) 
+ double calcularIMC() 
Pessoa nome da classe 
campos 
métodos 
Pessoa p = new Pessoa(1.85,65.0); 
double d = p.calcularIMC(); 
System.out.println("IMC = " + d); 
17 © ELFS 
Recursos disponíveis em Java para construir métodos 
•  Declarações: linhas de código terminadas por ponto-e-vírgula usadas 
para estabelecer os tipos dos identificadores usados no programa. 
Exemplos: 
•  Instruções: linhas de código terminadas por ponto-e-vírgula usadas 
para estabelecer ações: comandos de atribuição ou chamadas de 
métodos. Exemplos: 
int i; 
int j = 10; 
Pessoa p; 
Circulo c = new Circulo(10.0); 
i = 0; 
valor = v1 + v2 + v3; 
p = new Pessoa(1.85,65.0); 
System.out.println("IMC = " + p.calcularIMC()); 
18 © ELFS 
•  Blocos: conjuntos de declarações e instruções delimitados por chaves. 
Exemplo: 
•  Estruturas de controle: controlam como as instruções de um bloco 
devem ser executadas. Exemplos: 
{ 
 int valor1,valor2; 
 valor1 = v1 + v2 + v3; 
 valor2 = a + b; 
} 
if (i < j) 
{ 
 i = j; 
} 
else 
{ 
 j = 0; 
} 
for (int i = 0; i < 10; i++) 
{ 
 k = k + Math.sqrt(i); 
} 
while (i < 5) 
{ 
 System.out.println(2*i); 
 i++; 
} 
19 © ELFS 
Tipos primitivos de dados 
•  Em Java existem 8 tipos primitivos separados em quatro categorias: 
•  Para cada tipo primitivo há uma classe correspondente no pacote 
java.lang. Por exemplo: Integer (para o tipo int), Double (para o tipo 
double). 
•  Essas classes fornecem métodos para processamento dos valores do 
tipo primitivo (por exemplo, para converter um texto em um valor do 
tipo int ou um valor do tipo int em um texto). 
Categoria Tipos primitivos 
Lógico boolean 
Textual char 
Inteiro byte, short, int, long 
Ponto flutuante double, float 
20 © ELFS 
O tipo boolean 
•  Dois valores apenas para o tipo boolean: true e false. 
•  Operadores lógicos e booleanos 
boolean b = false; 
boolean deNovo; 
deNovo = (x < 10); 
Operador 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 == 1) && (y >= 5) false 
(x == 5) & (y >= 1) false 
(x == 1) || (y >= 5) true 
(x == 1) | (y >= 5) true 
(x == 1) ^ (y <= 5) false 
! ( y >= 5 ) true 
Sejam: 
 int x = 1; 
 int y = 4; 
21 © ELFS 
A diferença entre operadores lógicos e booleanos 
•  Operadores && ou ||: a expressão lógica é avaliada somente até que 
a verdade ou falsidade seja detectada (avaliação em curto-circuito). 
•  Operadores & e |: a expressão lógica é avaliada por inteiro, o que 
pode provocar efeitos colaterais. Por exemplo: 
double x[] = {1,2,3,4,5}; 
int i; 
... 
if ((i < 5) & (x[i] > 1.5)) 
... 
if ((i < 5) && (x[i] > 1.5)) 
Aqui pode ocorrer um erro, se 
a expressão (i < 5) for false. 
Aqui não. 
22 © ELFS 
Outros operadores 
•  Operadores aritméticos 
•  Operadores de igualdade 
Precedência Operador Operação Exemplo Resultado 
1 + Adição 7 + 2 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 
Operador Operação Exemplo Resultado 
== é igual a 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. 
23 © ELFS 
•  Operadores de incremento e de decremento 
•  Operadores relacionais 
Não pode haver 
espaço entre os 
símbolos dos 
operadores: 
== 
!= 
>= 
<= 
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 
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. 
24 © ELFS 
O tipo char e a classe String 
•  Um valor do tipo char representa um único 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. Strings 
devem ser escritos entre aspas. Exemplo: "Linguagem Java". 
Exemplos: 
•  char x = 'c'; a letra c 
•  char nl = '\n'; caractere de 'nova linha' 
•  char fi = '\u03A6'; a letra Ф 
•  String sigla = "PC2"; 
•  String nome = "Programação\n de Computadores II"; 
25 © ELFS 
Os tipos inteiros (byte, short, int, long) 
•  int é o tipo padrão para os inteiros. 
•  Os números inteiros podem ser utilizados em três formatos: decimal, 
octal e hexadecimal. 
 Exemplos: 
Valor Notação Observação 
56 decimal Notação usual 
070 octal Iniciado por 0 (zero). Notar que: (70)8 = (56)10 
0x38 hexadecimal Iniciado por 0x (zero xis). Notar que: (38)16 = (56)10 
56L longo Terminado por L ou l (valor inteiro do tipo long) 
Tipo Bits Intervalo de valores 
byte 8 [-128, 127] 
short 16 [-32768, 32767] 
int 32 [-2147483648, 2147483647] 
long 64 [-9223372036854775808, 9223372036854775807] 
26 © ELFS 
Os tipos de ponto flutuante (float, double) 
•  double é o tipo padrão para números de ponto flutuante. 
•  Valores do tipo float exigem a presença da letra F (ou f) ao final. 
 Exemplos: 
Valor Observação 
2.34 Valor de ponto flutuante escrito na notação usual 
0.234E1 Valor de ponto flutuante com expoente positivo 
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 
Tipo Bits Intervalo de valores 
float 32 [-3.40292347E+38, 3.40292347E+38] 
double 64 [-1.79769313486231570E+308, 1.79769313486231570E+308 ] 
27 © ELFS 
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: 
int long float double byte 
char 
short 
long a = 77L; // OK 
int b = a; // Errado 
int c = (int)a; // OK, mas... 
short d = 1, e = 1, f = 1; 
d = (short)(e + f); // Por que? 
float g = 3.14; // Erro! Por que? 
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 representa um objeto é conhecida como variável de 
referência (também chamada de ponteiro). 
Exemplo: 
28 © ELFS 
public class MinhaData 
{ 
 private int dia; 
 private int mes; 
 private int ano; 
 ... 
} 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). 
publicclass Teste 
{ 
 MinhaData d; 
 d = new MinhaData(22,3,2013); 
 ... 
} 
29 © ELFS 
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. 
•  Objetos são criados em uma área de memória da JVM conhecida como 
Heap. 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 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. 
30 © ELFS 
Exemplo: 
MinhaData d = new MinhaData(22,3,2013); 
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). 
Heap Stack 
d null 
31 © ELFS 
Exemplo: 
Heap 
0 
0 
0 
dia 
mes 
ano 
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. 
Stack 
d null 
MinhaData d = new MinhaData(22,3,2013); 
32 © ELFS 
Exemplo: 
Heap 
22 
3 
2013 
dia 
mes 
ano 
Em seguida, os parâmetros do construtor são usados para inicialização dos 
atributos (campos) do objeto criado. 
Stack 
d null 
MinhaData d = new MinhaData(22,3,2013); 
33 © ELFS 
Exemplo: 
Stack Heap 
d 22 
3 
2013 
dia 
mes 
ano 
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. 
0xF789 
MinhaData d = new MinhaData(22,3,2013); 
34 © ELFS 
Coleta de lixo 
•  Quando um ponteiro se perde (por exemplo, quando ele passa a 
apontar para outro objeto ou quando a ele é atribuído o valor null), o 
objeto para o qual apontava passa a ser um lixo (pois não haverá mais 
como acessar o objeto). 
•  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. 
Stack 
Heap 
d 22 
3 
2013 
dia 
mes 
ano 
0xF789 
35 © ELFS 
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 
Dentro de um retângulo 
existe uma ação (atribuição 
ou chamada de método). 
 String s = JOptionPane.showInputDialog("s:"); 
 int n = Integer.parseInt(s); 
 int a = n + 1; 
 System.out.println("a = " + a); 
36 © ELFS 
V 
F V 
F 
break 
V 
F 
break 
V 
F 
break 
... 
if 
if-else 
switch 
V F 
Estruturas de Seleção 
Dentro de um losango existe uma 
comparação (expressão do tipo boolean). 
37 © ELFS 
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). 
V 
F 
while 
do-while 
for 
V 
F 
V 
F 
Estruturas de Repetição 
38 © ELFS 
Exemplos: 
•  A estrutura if 
•  A estrutura if-else 
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"); 
} 
if (expressão booleana) 
 bloco1 
else 
 bloco2 
if (nota >= 7) 
{ 
 System.out.println("Aprovado"); 
} 
else 
{ 
 System.out.println("Exame final"); 
} 
39 © ELFS 
•  O operador ? corresponde a um if...else simples. 
•  A estrutura switch corresponde a uma seleção múltipla. 
String status = (nota >= 7 ? "Aprovado" : "Exame"); 
switch (expressão1) 
{ 
 case constante1: 
 comandos; 
 break; 
 case constante2: 
 comandos; 
 break; 
 default: 
 comandos; 
 break; 
} 
! 
A expressão1 deve corresponder a um 
valor do tipo: int, byte, short ou char. 
O caso default é opcional e será 
executado se nenhum dos casos 
anteriores o for. 
40 © ELFS 
•  A estrutura for 
•  A estrutura while 
•  A estrutura do-while 
for (exp1; exp2; exp3) 
 bloco 
while (exp) 
 bloco 
do 
 bloco 
while (exp); 
Atenção para o 
ponto-e-vírgula 
final. 
for (int i = 1; i < 10; i++) 
{ 
 System.out.println("i = " + i); 
} 
int i = 1; 
while (i < 10) 
{ 
 System.out.println("i = " + i); 
 i++; 
} 
int i = 1; 
do 
{ 
 System.out.println("i = " + i); 
 i++; 
} 
while (i < 10); 
41 © ELFS 
As instruções break e continue 
•  As instruções break e continue se aplicam apenas à estrutura de 
controle na qual estão contidas. 
•  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. 
42 © ELFS 
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 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 destruídas). 
•  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. 
43 © ELFS 
Campos e métodos estáticos 
•  Normalmente, os campos e métodos públicos de uma classe (lembrar 
que, em geral, os campos são privados) são dinâmicos, ou seja, devem 
ser acessados por meio de objetos da classe. 
•  Mas, uma classe pode declararcampos e métodos estáticos. Neste 
caso, o acesso a estes elementos da classe é feito pela própria classe, 
não havendo a necessidade de construir um objeto para isso. 
 Note que o acesso ao campo PI e ao método pow() é feito por meio da 
própria classe Math e não por um objeto da classe (não é possível criar 
objetos da classe Math). 
Temperatura t = new Temperatura(30); 
t.converterParaCelsius(); 
double area = Math.PI * Math.pow(r,2)); 
44 © ELFS 
Notar que os campos e métodos da classe Math são estáticos. 
Campos e (alguns) métodos da classe Math