在 Java 中，我们有两种类型的数据（或变量）：基元和非基元（也称为引用）。
基本类型将其文字值存储在堆栈、临时和短期存储内存中，由 Java 虚拟机 (JVM) 管理。 [在此处阅读有关内存类型的更多信息]
原始变量分为四组：
1。整数类型： 用于存储整数（不含小数部分）。它们是：byte、short、int、long。长数在数字末尾带有字母“L”或“l”，用于区分。
2。浮点类型：：用于存储带小数部分的数字（实数）。它们是：浮动、双精度。浮点数的数字末尾带有字母“F”或“f”，用于区分。
3。字符类型： 用于存储单个字符（如字母、数字或符号）：char。它们用单引号 '' 初始化，而不是双引号 ""。
4。布尔类型： 用于存储逻辑值（true 或 false）：bool
请参阅下表，了解每种类型的值范围以及“默认”值：
在科学格式中，E 代表指数。例如，1.23E+10 等于 1.23 x 10^10
什么是默认值？这是变量在未初始化的情况下将采用的值。然而，要假设这个值，它必须是全局的或恒定的（最终的）。
public final boolean isTrue;
登录后复制
在这行代码中，变量“isTrue”没有被初始化，但是编译器不会报错，因为它会考虑布尔变量的默认值“false”。
这里，一个重要的警告：如果变量的作用域是局部的，也就是说，如果它已经在函数内声明，我们程序员将被迫为其赋值。否则会出现编译错误。
public void teste(){
int i = 2;
int j;
if (i < 10){
j = 5;
}
System.out.println(j);
}
登录后复制
在这个例子中，即使我们知道“2 < 10”返回“true”，编译器在其过程中从不执行它翻译的代码，不知道条件为真，也不知道原始变量“j”将始终被初始化。这样，当尝试运行代码时，就会出现编译错误：“错误：变量 j 可能尚未初始化”。
内存地址
Java 中的第二种数据类型称为 引用。这些变量存储引用，即对象的内存地址，而不是像原始类型那样直接存储其值。此存储发生在堆内存中。
一般来说，引用类型是类、接口、枚举和对象。
这里是一个附录。我们在代码中广泛使用的 String 是一个类，而不是原始类型。请注意，即使是名称也是大写的，这是 Java 中类的命名约定。
String 甚至还有一些方法，例如 length()，它返回存储在其中的文本的大小，charAt(int index)，它返回文本中字符的索引，或者 substring(int beginIndex, int endIndex)，它返回一段字符串。
但是，如果您想让操作原始数据变得更容易，Java 也允许这样做。为此，它有 Wrapper 类，它已经附带了一系列内置方法来处理基本类型。
包装器基本上与原始变量具有相同的名称，但是第一个字母大写：
- 字节到字节
- 短裤短裤
- 整数到 int
- 长来长
- 浮来浮去
- 双倍到双倍
- 字符到字符
- 布尔值到布尔值
public class WrapperExample {
public static void main(String[] args) {
String numeroStr = "123";
Integer num1 = Integer.parseInt(numeroStr);
Integer num2 = 200;
int resultadoComparacao = Integer.compare(num1, num2);
if (resultadoComparacao < 0) {
System.out.println(num1 + " é menor que " + num2);
} else if (resultadoComparacao > 0) {
System.out.println(num1 + " é maior que " + num2);
} else {
System.out.println(num1 + " é igual a " + num2);
}
}
}
登录后复制
在此示例代码中，int 包装器用于将字符串转换为数字 (Integer.parse)，然后将其与另一个数字进行比较 (Integer.compare)。
然而，String 有一个其他类所没有的特殊性。她是一成不变的。
让我们通过这个基本示例来反思一下：
public class Main {
public static void main(String[] args) {
String text1 = "Hello";
String text2 = text1;
System.out.println(text1); //output: Hello
System.out.println(text2); //output: Hello
text1 = "Weird";
System.out.println(text1); //output: Weird
System.out.println(text2); //output: Hello
text2 = "World";
System.out.println(text1); //output: Weird
System.out.println(text2); //output: World
TestClass test1 = new TestClass("propertyValue");
TestClass test2 = test1;
System.out.println(test1.getProperty()); //output: propertyValue
System.out.println(test2.getProperty()); //output: propertyValue
test2.setProperty("newValue");
System.out.println(test1.getProperty()); //output: newValue
System.out.println(test2.getProperty()); //output: newValue
}
}
登录后复制
在这种情况下，请注意，即使字符串“text2”指向“text1”，“text2”中的更改也不会反映“text1”中的更改。现在，当指向“test1”的对象“test2”的属性发生更改时，此更改也会反映在“test1”中。
Hé, mais les variables de référence ne stockent-elles pas les adresses mémoire, au lieu des valeurs littérales ? Oui. Ils le stockent. Ce qui se passe, c'est que les développeurs du langage Java ont pris la décision de laisser les variables String immuables. Cela signifie que, une fois définie, la valeur d'un objet String ne peut pas être modifiée indirectement par un autre objet.
Par conséquent, dans l'exemple, nous ne modifions pas la valeur de l'objet précédemment référencé par text1 (puisque String est immuable). Au lieu de cela, nous créons un nouvel objet String avec la valeur "Weird" et faisons pointer text1 vers ce nouvel objet. Text2 pointera toujours vers l'objet "Hello" d'origine et c'est pourquoi il conservera la valeur "Hello".
En bref, attribuer une nouvelle valeur à une chaîne ne modifie pas la valeur de l'objet existant, cela change simplement la référence à un nouvel objet.
Les objets des classes personnalisées, telles que TestClass, sont mutables. Les références test1 et test2 pointent vers le même objet, donc changer l'état de l'une d'elles se reflète sur l'autre.
以上是Java 中的基本类型与引用以及字符串的不变性的详细内容。更多信息请关注PHP中文网其他相关文章！
