PC2 Aula02

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). 
2. Fundamentos da Linguagem Java 
− 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: 
2. Fundamentos da Linguagem Java 
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 
2. Fundamentos da Linguagem Java 
•  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). 
2. Fundamentos da Linguagem Java 
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 
2. Fundamentos da Linguagem Java 
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: 
2. Fundamentos da Linguagem Java 
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 
2. Fundamentos da Linguagem Java 
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 
2. Fundamentos da Linguagem Java 
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 
2. Fundamentos da Linguagem Java 
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: 
2. Fundamentos da Linguagem Java 
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: 
2. Fundamentos da Linguagem Java 
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? 
2. Fundamentos da Linguagem Java 
Variáveis de referência (ponteiros) 
•  Em Java, uma variável pode representar um valor de um dos tipos 
primitivosou 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; 
 ... 
} 
2. Fundamentos da Linguagem Java 
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). 
public class Teste 
{ 
 MinhaData d; 
 d = new MinhaData(22,3,2013); 
 ... 
} 
29 © ELFS 
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. 
•  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: 
q 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); 
q 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. 
q 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). 
2. Fundamentos da Linguagem Java 
Heap Stack 
d null 
31 © ELFS 
Exemplo: 
2. Fundamentos da Linguagem Java 
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: 
2. Fundamentos da Linguagem Java 
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: 
2. Fundamentos da Linguagem Java 
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. 
2. Fundamentos da Linguagem Java 
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 
2. Fundamentos da Linguagem Java 
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 
2. Fundamentos da Linguagem Java 
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 
2. Fundamentos da Linguagem Java 
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"); 
} 
2. Fundamentos da Linguagem Java 
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"); 
2. Fundamentos da Linguagem Java 
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. 
2. Fundamentos da Linguagem Java 
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. 
2. Fundamentos da Linguagem Java 
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 chamadasvariá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. 
2. Fundamentos da Linguagem Java 
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 declarar campos 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). 
2. Fundamentos da Linguagem Java 
Temperatura t = new Temperatura(30); 
t.converterParaCelsius(); 
double area = Math.PI * Math.pow(r,2)); 
44 © ELFS 
2. Fundamentos da Linguagem Java 
Notar que os campos e métodos da classe Math são estáticos. 
Campos e (alguns) métodos da classe Math 
45 © ELFS 
Exercício 1 
•  Construir a classe: 
 
 
•  O construtor deve atribuir o valor do parâmetro ao campo da classe. 
•  O método saldoApos(m,t) deve retornar inicial*(1 + t)m, onde t é 
a taxa de juros mensal e m é o número de meses. 
•  Construir a classe executável MinhaGrana que exibe o saldo do 
fundo no fim de cada mês, para um período de 12 meses, na forma: 
2. Fundamentos da Linguagem Java 
− double inicial 
+ Fundo(double) 
+ void saldoApos(int m, double t) 
Fundo 
Saldo inicial = xxx.xx 
Saldo apos 1 mes = xxx.xx 
Saldo apos 2 meses = xxx.xx 
... 
Saldo apos 12 meses = xxxx.xx 
46 © ELFS 
Exercício 2 
•  Construir a classe: 
 
 
•  O construtor deve atribuir o valor dos parâmetros aos campos valor e 
grau e atribuir o valor zero ao campo conversoes. 
•  O método converter() deve efetuar a conversão de CèF ou FèC 
dependendo do valor do campo grau e deve atualizar os campos 
valor, grau e conversoes. 
•  O método mostrar() deve exibir: v g (apos c conversoes), onde v é 
o valor do campo valor, g é o valor do campo grau e c é o valor do 
campo conversoes. 
•  Construir a classe executável Teste que utiliza os métodos da classe 
Temperatura. 
2. Fundamentos da Linguagem Java 
− double valor 
− char grau 
− int conversoes 
+ Temperatura(double, char) 
+ void converter() 
+ void mostrar() 
Temperatura 
Para converter: 
 
9C = 5(F – 32)