Programação I
Aula 3
(Entrada de Dados)
Prof. Gilberto Irajá Müller
Última atualização 11/3/2009
Métodos que retornam valor
• Quando um método termina sua execução, ele devolve
o controle da máquina para o método que o chamou.
Além disso, um método pode, neste momento, devolver
junto um valor
• Para que um método devolva um valor:
• na sua declaração, a palavra void deve ser substituída pelo tipo
do valor a ser devolvido pelo método
• no bloco de código do método deve haver pelo menos um
comando return expressão;
• a chamada do método deve ser feita no lugar onde caberia
colocar um valor do tipo que ele retorna
Métodos que retornam valor
• Sintaxe
• return expressão; (está relacionando com o tipo de retorno do método)
• return; (sair imediatamente do programa, retornando o valor nulo
correspondente ao tipo de dado
• Normalmente, encontramos nos métodos “getters”
Pessoa p1 = new Pessoa();
p1.setNome(“João da Silva”);
System.out.println(p1.getNome()); // uso do return
• Implementação do método getNome()
Public String getNome() {
return nome;
}
Métodos que retornam valor
• Podemos alterar o método exibeDados() da nossa classe Pessoa, utilizando
os métodos de retorno (getters):
public void exibeDados() {
System.out.println(“Nome: “ + getNome());
System.out.println(“Peso: “ + getPeso());
System.out.println(“Altura: “ + getAltura());
System.out.println(“Idade: “ + getIdade());
}
• Podemos utilizar o método de retorno na classe TestaPessoa, conforme
exemplo a seguir:
public class TestaPessoa{
public static void main(String args[]) {
Pessoa p1 = new Pessoa(“João da Silva”, 1.80, 80.0, 30);
System.out.println(“Nome da pessoa é: “ + p1.getNome());
}
}
Métodos que retornam valor
• Exercício. Desenvolva o diagrama de classes (UML) e implemente os
métodos “getters”. Após isso, crie a classe teste e instancie objetos, bem
como a visualização dos seus dados utilizando o System.out.println +
getter.
• A classe em questão é o usuário do MSN, ou seja, temos um usuário (que
é o e-mail) e sua senha. Após isso, identifique alguns atributos desta classe
de forma a gerar os métodos “getters”.
Entrada de dados
• Até o momento, apenas visualizamos a saída de dados e alteramos os
•
atributos de nossos objetos diretamente no código fonte
Então, vamos criar uma classe chamada TestaPessoa que permiterá entrar
com os dados via teclado e, após isso, criar o objeto com os dados
digitados pelo teclado
• Nossa classe de leitura do teclado (Teclado.java) possui três métodos:
•
•
•
•
public int leInt()
public double leDouble()
public String leString()
Os métodos acima são VOID? Porque?
• Precisaremos instanciar a classe Teclado.java (será fornecida pelo
professor).
• Teclado t = new Teclado();
Entrada de dados
• Exercício. Como ficaria nossa classe TestaPessoa solicitando os dados:
nome, altura, peso e idade?
Entrada de dados
• Exercício. Altere a classe Pessoa e inclua dois métodos:
• private double calculaIMC()
• public double getIMC()
• Detalhe: Solicite o nome, peso e altura para o cálculo. O cálculo do IMC é feito
através do peso / (altura2)
Entrada de dados (com mensagem)
• Aprendemos que a classe teclado possui três métodos para leitura de tipos
de diferentes (int, double e String)
• Contudo, nos exemplos anteriores, foi necessário colocar uma mensagem
antes da solicitação do valor do atributo
• Podemos utilizar os seguintes métodos que possuem a mensagem ao ser
solicitada a entrada do valor do atributo:
• public int leInt(String msg);
• public double leDouble(String msg);
• public String leString(String msg);
Entrada de dados (com mensagem)
• Exercício. Como ficaria a nossa classe TestaPessoa ao ser calculado o IMC
utilizando os métodos de entrada de dados com mensagem?
Entrada de dados (com mensagem)
• Exercício. Como não utilizar as variáveis locais? Até mesmo o objeto “p1”
para o método exibeDados?
Explique os problemas futuros na implementação
Expressões Aritméticas
• De forma indireta já estamos utilizando expressões aritméticas, em qual
momento?
Expressões Aritméticas
• Tipos de dados
• Inteiros correspondem aos números NATURAIS
• Números com casas decimais ou ponto flutuante correspondem aos
números REAIS
Expressões Aritméticas
• Números Inteiros:
• Java interpreta um número escrito sem ponto decimal como int.
Se o valor extrapolar os limites do tipo int, será tratado como
inteiro muito grande e dará erro de compilação. Para armazenar
um inteiro como long, devemos adicionar o sufixo L ou l ao
número.
• Ex:
• 1147465 é tratado como int, pois está na faixa do tipo int;
• 1147465L é tratado como long, devido ao sufixo;
• 3000000000 dá o erro de compilação integer number too large.
Expressões Aritméticas
• Exercício
• Complete as linhas seguintes:
•
•
•
•
-5 é tratado como _____________
-34567890987 é tratado como _____________________
-5L é do tipo _____________
"50" é do tipo ____________
Expressões Aritméticas
• Números de ponto flutuante
• Em Java, número com ponto decimal é tratado como double.
• Caso o valor estiver numa faixa viável ao tipo float, podemos
usar o sufixo F ou f para que ele seja tratado
• O sufixo D ou d também pode ser usado para informar ao
compilador que desejamos tratá-lo como double.
• Ex:
•
•
•
•
•
3.1415 é tratado como double;
3.1415F é float;
3.141524357576575789 é tratado como double;
3.141592837646473637F será um float;
4D será um double, que valerá 4.0;
Expressões Aritméticas
• Exercício.
• Complete as seguintes linhas:
•
•
•
•
-1837469382988983909.7 é do tipo _________
-456.678787997907575796795797F é __________
5F é __________
“5F” é do tipo _________
Expressões Aritméticas
• O tipo primitivo char
• O tipo primitivo char corresponde a um único caractere
(Unicode) escrito entre apóstrofos, que ocupa espaço de dois
bytes no seu armazenamento.
Ex: 'a', 'M', '+', '?‘
• Uma variável pode ser do tipo char.
• Ex: char c = 'C';
• Caracteres de escape
• Representam caracteres especiais que podem ser atribuídos às
variáveis do tipo char e String, ou podem fazer parte de um
string.
Expressões Aritméticas
• Caracteres de escape
Expressões Aritméticas
• Classe que demonstra o limite de cada tipo de
dado
•
public class testaTipoDado {
public static void main(String[] args) {
System.out.println("Tipos de dados em Java: \n" +
"\nMenor Byte: " + Byte.MIN_VALUE +
"\nMaior Byte: " + Byte.MAX_VALUE +
"\nMenor Short Int: " + Short.MIN_VALUE +
"\nMaior Short Int: " + Short.MAX_VALUE +
"\nMenor Int: " + Integer.MIN_VALUE +
"\nMaior Int: " + Integer.MAX_VALUE +
"\nMenor Long: " + Long.MIN_VALUE +
"\nMaior Long:" + Long.MAX_VALUE +
"\nMenor Float: " + Float.MIN_VALUE +
"\nMaior Float: " + Float.MAX_VALUE +
"\nMenor Double: " + Double.MIN_VALUE +
"\nMaior Double: " + Double.MAX_VALUE);
}
}
Expressões Aritméticas
• Conversão entre tipos de dados
• Conversão implícita
• É permitido converter qualquer tipo abaixo para um que esteja à
sua esquerda, sem qualquer artifício, e sem perda de precisão:
• double <- float <- long <- int <- short <- byte
• Exemplo:
long x = 12678;
double dd = x; // dd ficará com 12678.0
byte y = -2;
short s = y; // s assumirá valor -2
int i = y; // i ficará com -2
Expressões Aritméticas
• Conversão explícita (Coerção ou cast).
• Usa-se um conversor (ou cast), que é a colocação do tipo de
destino entre parênteses antes do valor a ser convertido
• Ex:
double dd = 6.789;
int ii = (int) dd; // ii guardará o valor 6, pois a conversão
descarta a parte decimal
short s = (short) ii; //s guardará 6 – não houve perda
nenhuma
byte b = (byte) 6.7; //perde-se a parte decimal
short s = (short) 50000; // CUIDADO – como o tipo short não
comporta 50000, será atribuído um valor aleatório a s – erro
que não é acusado pelo sistema
Expressões Aritméticas
• Operadores aritméticos básicos
• Na ordem decrescente de prioridade dentro de uma expressão
aritmética:
• 1º. ) * (multiplicação) / (divisão) % (módulo, ou resto da divisão
inteira)
• 2º. ) + (adição) - (subtração)
• Ex: x * y
• 7/n
• m % n // resto da divisão inteira de m por n
Expressões Aritméticas
• Regras importantes
• Geralmente, a operação resulta um tipo que é grande o
•
•
•
•
suficiente para conter o resultado. Por exemplo, multiplicando
um float por um int obtém-se um float.
• Ex: 4F * 2 resulta 8.0F
O resultado da divisão de dois inteiros é sempre inteiro.
• Ex: 7 / 2 resulta 3.
A presença de um float ou double na expressão, causa um
resultado float ou double.
• Ex: 7F / 2 resulta 3.5.
Quando há mais de um operador, as regras de prioridades serão
respeitadas.
• Ex: 4 + 7 / 2 resultará 7, pois a divisão é feita antes da adição.
Subexpressões entre parênteses terão maior prioridade.
• Ex: (4 + 7) / 2.0 resultará 5.5.
Expressões Aritméticas
• Exercícios
• Indique o valor e o tipo do resultado de cada expressão abaixo:
•
•
•
•
5000000000L + 500
5F * 3.0
(3 + 4) / (2 * 2)
2 * (3.5 + (7 + 2) * 3.0) / 2
• Indique que valor será gravado nas respectivas variáveis nas
atribuições abaixo, ou informe se é operação inválida e porquê.
• double x = 3 * 5;
• int i = 5 / 2f;
• int i = i + 1;
Expressões Aritméticas
• Operadores de atribuição
• Pode-se combinar uma operação com uma atribuição. Por
exemplo, a atribuição n=n+2; pode ser escrita como n+=2;
• Os diversos operadores de atribuição de Java são mostrados na
tabela seguinte:
Expressões Aritméticas
• Operadores de atribuição
• Exemplo:
int k = 6; int s = 2;
s += k; // mesmo que s = s + k; s = 8, k = 6
s %= 5; // mesmo que s = s % 5; (resto da divisão de s por 5).
s=3
Expressões Aritméticas
• Operadores de incremento e de decremento
• É muito comum nos programas incrementar 1 a uma variável, o
que se pode fazer, como já foi visto, de duas maneiras. Por
exemplo,
int m = 10;
m = m + 1; // incrementa 1 a 10, resultando 11 em m
m += 1; // m irá para 12
• Os operadores ++ e -- realizam a tarefa de incrementar ou
decrementar 1.
• Ex:
m++; // mesmo que m = m + 1;
m--; // mesmo que m = m – 1;
double d = 6.51;
d++; // podem ser aplicados a campos de ponto flutuante
Expressões Aritméticas
• Operadores de incremento e de decremento
• Os operadores de incremento e de decremento podem ser pós-
fixados, quando vêm colocados após a variável, ou pré-fixados,
quando vêm antes. Se pós-fixado, a variável é utilizada e depois
é incrementada (ou decrementada). Se pré-fixado, a variável é
incrementada (ou decrementada) e depois utilizada.
• Ex: o trecho
int i = 5;
System.out.println(++i + “ “ + i++ + “ “ + i);
QUAL A SAÍDA DA INSTRUÇÃO ACIMA?
Expressões Aritméticas
• Exercício. Que valores serão exibidos pelo trecho
abaixo?
int a = 15;
int b = 4;
int c = a++ + --b;
System.out.println(a + “ “ + b + “ “ + c);
Expressões Aritméticas
• A classe Math
• A classe java.lang.Math possui diversos métodos que implementam operações
matemáticas úteis. Seu uso dispensa o comando import (veremos adiante)
pois ela é carregada automaticamente.
• static double random( )
• Retorna um double randômico no intervalo [0, 1.0).
• Ex: double r = Math.random(); // grava em r um randômico
• Ex: int i = 1 + (int) (Math.random() * 10) // grava em i um randômico
obtido no intervalo de 1 a 10.
• static double sqrt (double a)
• Retorna um double que é a raiz quadrada positiva de a.
• Ex: double y = 25;
• System.out.println (Math.sqrt(y)); //Exibe 5.0
• static double pow (double b, double e)
• Eleva a base b ao expoente e, retornado double.
• Ex: double p = Math.pow(2, 3); // atribui 8.0 a p
Expressões Aritméticas
• Exercício. Escrever em Java a fórmula de Bhaskara
Expressões Aritméticas
• Exercício. Crie uma classe Circulo e os métodos
calculaArea e calculaPerimetro da classe Circulo. Eles
devem devolver os valores calculados. Crie uma classe
TestaCirculo para criar um objeto círculo e imprimir sua
área e seu perímetro.
• Área do círculo: Pi x r2
• Perímetro: 2 * Pi x r
• Para o valor do Pi, utilize Math.PI
Métodos
• Referências bibliográficas
• http://inf.unisinos.br/~anibal
• http://www.google.com.br