RESUMO 3 (Página 30 a 40)
2.2) Escolhendo bons nomes para variáveis e constantes
Para escolher o nome de variáveis tem que se ter em atenção alguns aspetos :
O seu algoritmo poderá ser lido por outros programadores;
O nome da variável deve estar relacionado com o que se trata, para não causar confusão, caso não tenha um comentário, a pessoa que vai ler o codigo
E começa o nome das variáveis em minúscula;
Ex: uma variável para “distância percorrido”:
– mau:
disPer, disper ou dp// se não tiver comentado a pessoa que vai ler poderá ter dificuldades ao ter contacto com seu codigo.
-recomendável:
distanciaPercorrida.
Capítulo 3
Entrada de dados
Com a entrada de dado torna nossos algoritmos, realmente, dinâmicos é o fato de podemos receber dados externos a ele e dentro do Java temos algumas técnicas para conseguir isso.
3.1) Lendo informações com o Scanner
O Scanner é uma funcionalidade do Java que nos permite capturar um valor do usuário do nosso programa através do terminal, para usar faz-se:
Scanner scanner = new Scanner(System.in);
double distanciaPercorrida = scanner.nextDouble();
scanner.close();
Entendendo o que foi feito acima, a primeira linha está declarando uma variável chamada scanner para preparar o recurso, para que ele possa ser utilizado:
Scanner scanner = new Scanner(System.in);
Na segunda linha, ela para o programa até que o usuário informe um valor e aperte a tecla ENTER: double distanciaPercorrida = scanner.nextDouble();
A terceira e última linha é uma funcionalidade que o recurso Scanner possui para encerra a sua utilidade.
Bom, mas antes de usar este recurso temos que informar antes na primeira linha de codigo para que o compilador de Java passa a saber e ter conhecimento do uso. E faz-se da seguinte forma:
import java.util.Scanner;
3.2) Lendo diferentes tipos de dados
Da mesma forma que podemos declarar variáveis de diferentes tipos (numéricos, textos, booleanos, etc.), visto no capítulo sobre as variáveis assim também podemos ler, através do termina. Aqui está um pequeno programa com código e os comandos de leitura para cada tipo de dado tipos (numéricos, textos, booleanos, etc.):
import java.util.Scanner;
public class LendoDiferentesTiposDeDados { public static void main(String[] args) { System.out.println(“====================”);
Scanner scanner = new Scanner(System.in);
// ———————————————-
System.out.print(” >>> Digite um texto: “);
String texto = scanner.nextLine();
System.out.println(“O texto digitado ” + “foi ” + texto);
// ———————————————-
// Apesar do Java trabalhar com o “.” como
// separador de decimais, o Scanner vai receber
// um decimal no formato em que seu computador estiver
// configurado, ou seja, se você usa o
// português brasileiro, então, para digitar,
// terá que usar a vírgula como separador
// de decimais. A própria funcionalidade Scanner vai
// transformar o número com vírgula em algo
// que o Java entenda, ou seja, um número
// que tem o “.” como separador de decimais.
System.out.print(” >>> Digite um decimal: “);
double numeroDecimal = scanner.nextDouble();
System.out.println(“O número decimal digitado ” + “foi ” + numeroDecimal);
// ———————————————-
System.out.print(” >>> Digite um inteiro: “);
int numeroInteiro = scanner.nextInt();
System.out.println(“O número inteiro digitado ” + “foi ” + numeroInteiro);
// ———————————————-
System.out.print(” >>> Digite um boolean (true ou false): “);
boolean booleano = scanner.nextBoolean();
System.out.println(“O booleano digitado ” + “foi ” + booleano);
// ———————————————-
scanner.close();
System.out.println(“Fim!”);
System.out.println(“====================”);
}
}
Capítulo 4
Operadores
Os operadores são recursos super importantes dentro da lógica de programação e, das linguagens de programação. Eles nos permitem fazer cálculos, estabelecer relações, atribuir valores e tomar decisões dentro dos nossos algoritmos.
4.1) Operadores aritméticos
Os operadores aritméticos permitem realizar cálculos matemáticos básicos, são eles:
• + e – (adição e subtração)
• * e / (multiplicação e divisão)
• % (módulo ou resto de uma divisão)
Esses operadores são aqueles que aprendemos na matemática e já os conhecemos, então para ajudar aqui está um pequeno programa com exemplos:
public class OperadoresAritmeticos {
public static void main (String [] args) { System.out.println(“===============================”);
int adicao = 5 + 2;
System.out.println(“Resultado da adição de 5 com 2: ” + adicao);
int subtracao = 5 – 2;
System.out.println(“Resultado da subtração de 5 pelo 2: ” + subtracao);
int multiplicacao = 5 * 2;
System.out.println(“Resultado da multiplicação de 5 pelo 2: ” + multiplicacao);
double divisao = 5.0 / 2.0;
System.out.println(“Resultado da divisão de 5 pelo 2: ” + divisao);
double moduloOuResto = 5.0 % 2.0;
System.out.println(“Resto da divisão de 5 pelo 2: ” + moduloOuResto); System.out.println(“Fim!”);
System.out.println(“===============================”);
}
}
4.2) Operadores de atribuição
Operadores de atribuição são aqueles que fazem com que um valor qualquer – um número, por exemplo – passe para uma variável.
O mais comum deles é o operador “=” (igual).
Veja ele sendo utilizado abaixo: String ultimoNome = “Silva”;
Os outros operadores de atribuição que temos é o operador “=” combinado com algum operador aritmético, são eles:
• +=
• -= •
*=
• /=
• %=
Esses operadores não são essenciais dentro da programação, mas ajudam a simplificar o código. Por exemplo, o trecho abaixo:
int umNumero = 5;
umNumero = umNumero + 2;
// A variável umNumero vai guardar o valor 7 … pode ser substituído por: int umNumero = 5; umNumero += 2; // A variável umNumero vai continuar guardando o valor 7.
Aqui está um exemplo de utilidade dos operadores de atribuição:
public class OperadoresDeAtribuicao {
public static void main(String[] args) { System.out.println(“===============================”);
int umNumero = 5;
umNumero += 2;
System.out.println(“Resultado da adição de 5 com 2: ” + umNumero);
umNumero = 5; // Voltando o valor para 5.
umNumero -= 2;
System.out.println(“Resultado da subtração de 5 pelo 2: ” + umNumero);
umNumero = 5; // Voltando o valor para 5.
umNumero *= 2;
System.out.println(“Resultado da multiplicação de 5 pelo 2: ” + umNumero);
umNumero = 5; // Voltando o valor para 5.
umNumero /= 2; System.out.println(“Resultado da divisão de 5 pelo 2: ” + umNumero); umNumero = 5; // Voltando o valor para 5. umNumero %= 2;
System.out.println(“Resto da divisão de 5 pelo 2: ” + umNumero);
System.out.println(“Fim!”);
System.out.println(“===============================”);
}
}
