Neste laboratório, você aprenderá como determinar se um número em Java é um double. Exploraremos diferentes técnicas, começando por verificar se um objeto é uma instância da classe wrapper Double usando o operador instanceof.
Em seguida, você aprenderá como converter uma string para um double e lidar com possíveis erros. Finalmente, abordaremos como diferenciar entre os tipos Double e Integer para garantir que você está trabalhando com a representação numérica correta.
Nesta etapa, exploraremos a classe Double em Java e aprenderemos como verificar se um objeto é uma instância desta classe. Em Java, tipos de dados primitivos como double têm classes wrapper correspondentes, como Double. A classe Double fornece métodos úteis para trabalhar com números de ponto flutuante de dupla precisão.
Primeiro, vamos criar um novo arquivo Java chamado DoubleCheck.java no seu diretório ~/project. Você pode fazer isso usando o Explorador de Arquivos da WebIDE à esquerda. Clique com o botão direito no diretório ~/project, selecione "Novo Arquivo" e digite DoubleCheck.java.
Agora, abra o arquivo DoubleCheck.java no editor e adicione o seguinte código:
public class DoubleCheck {
public static void main(String[] args) {
// Declare a primitive double variable
double primitiveDouble = 123.45;
// Declare a Double object
Double doubleObject = 67.89;
// Declare an Integer object
Integer integerObject = 100;
// Check if primitiveDouble is an instance of Double (This will not work directly)
// System.out.println("Is primitiveDouble an instance of Double? " + (primitiveDouble instanceof Double)); // This line would cause a compile error
// Check if doubleObject is an instance of Double
System.out.println("Is doubleObject an instance of Double? " + (doubleObject instanceof Double));
// Check if integerObject is an instance of Double
System.out.println("Is integerObject an instance of Double? " + (integerObject instanceof Double));
}
}Neste código:
double chamada primitiveDouble.Double chamado doubleObject.Integer chamado integerObject para comparação.instanceof para verificar se doubleObject e integerObject são instâncias da classe Double.instanceof não pode ser usado diretamente com tipos primitivos como double.Salve o arquivo DoubleCheck.java.
Agora, vamos compilar e executar o programa. Abra o Terminal na parte inferior da WebIDE. Certifique-se de estar no diretório ~/project.
Compile o código usando javac:
javac DoubleCheck.javaSe não houver erros de compilação, execute o código compilado usando java:
java DoubleCheckVocê deve ver uma saída semelhante a esta:
Is doubleObject an instance of Double? true
Is integerObject an instance of Double? falseEsta saída confirma que doubleObject é uma instância da classe Double, enquanto integerObject não é. Isso demonstra como usar o operador instanceof para verificar o tipo de um objeto em Java.
Nesta etapa, aprenderemos como converter uma String que representa um número em um valor double em Java. Esta é uma tarefa comum quando você recebe entrada numérica como texto, por exemplo, de entrada do usuário ou leitura de um arquivo. A classe Double fornece um método estático chamado parseDouble() especificamente para este fim.
Vamos criar um novo arquivo Java chamado StringtoDouble.java no seu diretório ~/project. Use o Explorador de Arquivos da WebIDE para criar este arquivo.
Abra StringtoDouble.java e adicione o seguinte código:
public class StringtoDouble {
public static void main(String[] args) {
// A string representing a double value
String doubleString = "987.65";
// Another string representing a double value
String anotherDoubleString = "3.14159";
// A string that is not a valid double
String invalidDoubleString = "hello";
// Parse the strings to double values
try {
double parsedDouble1 = Double.parseDouble(doubleString);
double parsedDouble2 = Double.parseDouble(anotherDoubleString);
System.out.println("Parsed double from \"" + doubleString + "\": " + parsedDouble1);
System.out.println("Parsed double from \"" + anotherDoubleString + "\": " + parsedDouble2);
// Attempt to parse an invalid string (This will cause an error)
// double parsedDouble3 = Double.parseDouble(invalidDoubleString);
// System.out.println("Parsed double from \"" + invalidDoubleString + "\": " + parsedDouble3);
} catch (NumberFormatException e) {
System.out.println("Error parsing string: " + e.getMessage());
}
}
}Neste código:
doubleString e anotherDoubleString, que contêm representações válidas de números double.invalidDoubleString que não representa um número válido.Double.parseDouble() para converter as strings válidas em valores primitivos double.try-catch. Isso é importante porque, se a string não puder ser convertida em um double válido (como invalidDoubleString), parseDouble() lançará uma NumberFormatException. O bloco catch lida com este erro de forma adequada.Salve o arquivo StringtoDouble.java.
Agora, vamos compilar e executar o programa. Abra o Terminal e certifique-se de estar no diretório ~/project.
Compile o código:
javac StringtoDouble.javaExecute o código compilado:
java StringtoDoubleVocê deve ver uma saída semelhante a esta:
Parsed double from "987.65": 987.65
Parsed double from "3.14159": 3.14159Se você descomentar as linhas que tentam analisar invalidDoubleString e executar o código novamente, você verá a mensagem de erro do bloco catch, demonstrando como o programa lida com entrada inválida.
Esta etapa mostra como converter representações de string de números em valores double reais, o que é uma habilidade crucial para lidar com entrada em seus programas Java.
Nesta etapa, exploraremos como diferenciar entre valores double e int (inteiro) em Java, especialmente ao lidar com números que podem parecer semelhantes. Embora double possa representar números com casas decimais e também números inteiros, int só pode representar números inteiros. Compreender essa diferença é crucial para escolher o tipo de dados correto e realizar cálculos precisos.
Vamos criar um novo arquivo Java chamado NumberTypes.java no seu diretório ~/project usando o Explorador de Arquivos da WebIDE.
Abra NumberTypes.java e adicione o seguinte código:
public class NumberTypes {
public static void main(String[] args) {
// An integer variable
int integerValue = 10;
// A double variable representing a whole number
double doubleValueWhole = 20.0;
// A double variable representing a number with a decimal part
double doubleValueDecimal = 30.5;
// Print the values and their types (implicitly)
System.out.println("Integer value: " + integerValue);
System.out.println("Double value (whole): " + doubleValueWhole);
System.out.println("Double value (decimal): " + doubleValueDecimal);
// Check the type using instanceof (for wrapper classes)
Integer integerObject = 100;
Double doubleObject = 200.0;
System.out.println("Is integerObject an instance of Integer? " + (integerObject instanceof Integer));
System.out.println("Is doubleObject an instance of Double? " + (doubleObject instanceof Double));
System.out.println("Is integerObject an instance of Double? " + (integerObject instanceof Double));
System.out.println("Is doubleObject an instance of Integer? " + (doubleObject instanceof Integer));
// Demonstrate potential issues with comparing double and int
System.out.println("Is integerValue equal to doubleValueWhole? " + (integerValue == doubleValueWhole)); // This comparison works due to type promotion
// System.out.println("Is integerValue equal to doubleValueDecimal? " + (integerValue == doubleValueDecimal)); // This would be false
}
}Neste código:
int chamada integerValue.double, uma representando um número inteiro (doubleValueWhole) e outra com uma parte decimal (doubleValueDecimal).instanceof com as classes wrapper Integer e Double para verificar explicitamente os tipos de objeto, semelhante ao que fizemos na primeira etapa.int e um double. Java realiza a promoção de tipo, convertendo o int em um double antes da comparação, então integerValue == doubleValueWhole avalia como true.Salve o arquivo NumberTypes.java.
Agora, vamos compilar e executar o programa. Abra o Terminal e certifique-se de estar no diretório ~/project.
Compile o código:
javac NumberTypes.javaExecute o código compilado:
java NumberTypesVocê deve ver uma saída semelhante a esta:
Integer value: 10
Double value (whole): 20.0
Double value (decimal): 30.5
Is integerObject an instance of Integer? true
Is doubleObject an instance of Double? true
Is integerObject an instance of Double? false
Is doubleObject an instance of Integer? false
Is integerValue equal to doubleValueWhole? trueEsta saída ajuda a ilustrar a diferença entre como os valores int e double são armazenados e representados, e como você pode usar instanceof com suas classes wrapper para verificar seus tipos. Embora um double possa conter um valor de número inteiro, ele ainda é fundamentalmente um tipo de ponto flutuante, distinto de um tipo inteiro.
Neste laboratório, aprendemos como verificar se um número é um Double em Java. Começamos explorando a classe wrapper Double e usando o operador instanceof para determinar se um objeto é uma instância de Double. Observamos que instanceof funciona com objetos Double, mas não diretamente com tipos primitivos double.
