(超等具体版)Java根本:Java常用变量详解

发表于 2025-12-30 01:27:12

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

×

在Java编程中，变量是存储数据的根本单位。相识和精确利用变量是把握Java编程的关键一步。本文将具体先容Java中的常用变量范例，包罗根本数据范例和引用数据范例，并探究它们的利用场景和注意事项。
一、根本数据范例（Primitive Data Types）

Java提供了八种根本数据范例，这些范例是Java中最根本的变量范例，用于存储简单的数据。
1. 整数范例（Integer Types）

（1）byte

界说：byte 是 Java 中最小的整数范例，占 1 个字节（8 位），取值范围是 -128 到 127。
利用场景：实用于必要节省内存且数据范围较小的场景，如处置惩罚二进制数据或文件流。

byte b = 100;

复制代码

（2）short

界说：short 占 2 个字节（16 位），取值范围是 -32,768 到 32,767。
利用场景：实用于中等巨细的整数，但较少利用。

short s = 10000;

复制代码

（3）int

界说：int 占 4 个字节（32 位），取值范围是 -2^31 到 2^31-1。
利用场景：最常用的整数范例，实用于大多数整数场景。

int i = 100000;

复制代码

（4）long

界说：long 占 8 个字节（64 位），取值范围是 -2^63 到 2^63-1。
利用场景：实用于必要更大取值范围的整数，如时间戳、大数值盘算等。
注意事项：long 范例的字面值必要在数字反面加上 L 或 l 以标识。

long l = 100000L;

复制代码

2. 浮点范例（Floating-Point Types）

（1）float

界说：float 占 4 个字节（32 位），用于表现单精度浮点数。
利用场景：实用于对精度要求不高的浮点数盘算。
注意事项：float 范例的字面值必要在数字反面加上 F 或 f 以标识。

float f = 3.14F;

复制代码

（2）double

界说：double 占 8 个字节（64 位），用于表现双精度浮点数。
利用场景：最常用的浮点范例，实用于大多数科学盘算和工程盘算。

double d = 3.14159;

复制代码

3. 字符范例（Character Type）

（1）char

界说：char 占 2 个字节（16 位），用于表现单个字符，利用单引号 ' 括起来。
利用场景：实用于表现字符常量，如字母、数字字符、符号等。

char c = 'A';

复制代码

4. 布尔范例（Boolean Type）

（1）boolean

界说：boolean 范例只占 1 位，用于表现逻辑值，只能取 true 或 false。
利用场景：实用于条件判断和逻辑控制。

boolean flag = true;

复制代码

二、引用数据范例（Reference Data Types）

引用数据范例是指对象范例的变量，它们是通过引用（内存地点）来访问对象的。
1. 类（Class）

（1）界说

界说：类是 Java 中最常见的引用范例，界说了对象的属性和方法。
利用场景：实用于复杂的对象模子和面向对象编程。

class Book {
String title;
String author;
}
Book book = new Book();

复制代码

2. 数组（Array）

（1）界说

界说：数组是一种用于存储固定巨细、同范例元素的数据结构。数组一旦创建，其巨细不可改变。
利用场景：实用于存储和处置惩罚一组雷同范例的数据，如学天生绩、一组数字等。

（2）声明和初始化

// 一维数组
int[] numbers = new int[5]; // 声明一个长度为5的int类型数组
numbers[0] = 1; // 赋值
// 也可以直接初始化
int[] numbers = {1, 2, 3, 4, 5}; // 声明并初始化
// 多维数组
int[][] matrix = new int[3][3]; // 声明一个3x3的二维数组
matrix[0][0] = 1; // 赋值
// 直接初始化二维数组
int[][] matrix = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};

复制代码

（3）注意事项

固定巨细：数组的巨细在创建时确定，之后不能改变。
索引从0开始：数组的索引从0开始，到length-1竣事。
多维数组：可以创建多维数组，如二维数组（矩阵）、三维数组等。

3. 字符串（String）

（1）界说

界说：String 是一种特殊的引用范例，用于表现字符串。固然它是引用范例，但它的值是不可变的（immutable）。
利用场景：实用于处置惩罚文本数据，如句子、单词、文件路径等。

（2）声明和初始化

String str = "Hello, World!"; // 声明并初始化一个字符串

复制代码

（3）常用方法

length()：返回字符串的长度。

int length = str.length(); // 返回13

复制代码

charAt(int index)：返回指定索引处的字符。

char ch = str.charAt(0); // 返回 'H'

复制代码

substring(int beginIndex, int endIndex)：返回子字符串。

String subStr = str.substring(0, 5); // 返回 "Hello"

复制代码

equals(Object anotherObject)：比力字符串内容是否相称。

boolean isEqual = str.equals("Hello, World!"); // 返回 true

复制代码

toUpperCase() 和 toLowerCase()：将字符串转换为大写或小写。

String upperStr = str.toUpperCase(); // 返回 "HELLO, WORLD!"
String lowerStr = str.toLowerCase(); // 返回 "hello, world!"

复制代码

（4）注意事项

不可变性：字符串一旦创建，其内容不可改变。任何修改操纵都会创建一个新的字符串对象。
字符串池：Java 对字符串举行了优化，利用字符串池（String Pool）来存储字符串常量，以进步性能。

4. 摆列（Enum）

（1）界说

界说：enum 是一种特殊的类范例，用于表现一组固定的常量。
利用场景：实用于表现一组有限的选项或状态，如星期几、颜色等。

（2）声明和利用

enum Day {
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
Day day = Day.MONDAY; // 使用枚举

复制代码

（3）常用方法

values()：返回摆列常量的数组。

Day[] days = Day.values(); // 返回所有枚举常量

复制代码

valueOf(String name)：根据名称获取摆列常量。

Day day = Day.valueOf("MONDAY"); // 返回 Day.MONDAY

复制代码

（4）注意事项

（2）声明和利用

interface Animal {
void eat();
void sleep();
}
class Dog implements Animal {
@Override
public void eat() {
System.out.println("Dog is eating");
}
@Override
public void sleep() {
System.out.println("Dog is sleeping");
}
}
public class InterfaceExample {
public static void main(String[] args) {
Animal myDog = new Dog();
myDog.eat(); // 输出: Dog is eating
myDog.sleep(); // 输出: Dog is sleeping
}
}

复制代码

（3）默认方法和静态方法

interface Animal {
void eat();
void sleep();
// 默认方法
default void play() {
System.out.println("Animal is playing");
}
}

复制代码

interface Animal {
static void sound() {
System.out.println("Some animal sound");
}
}
public class InterfaceExample {
public static void main(String[] args) {
Animal.sound(); // 输出: Some animal sound
}
}

复制代码

（4）注意事项

6. 泛型（Generics）

（1）界说

（2）泛型类

class Box<T> {
private T item;
public void set(T item) {
this.item = item;
}
public T get() {
return this.item;
}
}
public class GenericsExample {
public static void main(String[] args) {
Box<String> stringBox = new Box<>();
stringBox.set("Hello, World!");
System.out.println(stringBox.get()); // 输出: Hello, World!
Box<Integer> intBox = new Box<>();
intBox.set(123);
System.out.println(intBox.get()); // 输出: 123
}
}

复制代码

范例安全：摆列范例是范例安全的，比利用整数常量更安全和易读。
摆列方法：摆列本质上是一个特殊的类，因此可以为其界说构造方法、成员变量和方法。
2. enum Day {
3. MONDAY("Weekday"), TUESDAY("Weekday"), WEDNESDAY("Weekday"), THURSDAY("Weekday"), FRIDAY("Weekday"), SATURDAY("Weekend"), SUNDAY("Weekend");
5. private String type;
7. // 构造方法
8. Day(String type) {
9. this.type = type;
10. }
12. // 获取类型
13. public String getType() {
14. return this.type;
15. }
16. }
18. public class EnumExample {
19. public static void main(String[] args) {
20. Day day = Day.MONDAY;
21. System.out.println(day + " is a " + day.getType()); // 输出: MONDAY is a Weekday
22. }
23. }
复制代码
switch 语句：摆列可以与 switch 语句一起利用，以实现更清楚的逻辑控制。
2. Day day = Day.MONDAY;
3. switch (day) {
4. case MONDAY:
5. System.out.println("Start of the work week");
6. break;
7. case FRIDAY:
8. System.out.println("End of the work week");
9. break;
10. default:
11. System.out.println("Weekend");
12. }
复制代码
5. 接口（Interface）

（1）界说
界说：接口是一种引用范例，雷同于类，但只包罗常量和抽象方法的界说。
利用场景：实用于界说对象的举动规范，使差别的类可以依照雷同的接口实现相似的功能。
默认方法：从 Java 8 开始，接口可以包罗默认方法，这些方法有默认实现。
静态方法：接口也可以包罗静态方法，这些方法属于接口本身。
多继续：一个类可以实现多个接口，这在某种水平上实现了多继续。
抽象左券：接口重要用于界说对象的举动左券，不涉及具体的实现细节。
界说：泛型是 Java 提供的一种机制，允许在类、接口和方法中利用范例参数，从而实当代码的复用性和范例安全性。
利用场景：实用于必要处置惩罚差别范例的数据结构和算法，如聚集、映射等。

3）泛型方法

界说：泛型方法是可以在方法级别界说范例参数的方法，独立于类的范例参数。

class GenericsMethodExample {
// 泛型方法
public static <T> void printArray(T[] array) {
for (T item : array) {
System.out.println(item);
}
}
public static void main(String[] args) {
Integer[] intArray = {1, 2, 3, 4, 5};
String[] stringArray = {"A", "B", "C"};
printArray(intArray); // 输出: 1 2 3 4 5
printArray(stringArray); // 输出: A B C
}
}

复制代码

（4）泛型接口

界说：接口也可以利用泛型，从而使实现类根据必要指定范例参数。

interface GenericInterface<T> {
T getValue();
}
class GenericInterfaceImpl<T> implements GenericInterface<T> {
private T value;
public GenericInterfaceImpl(T value) {
this.value = value;
}
@Override
public T getValue() {
return this.value;
}
}
public class InterfaceGenericsExample {
public static void main(String[] args) {
GenericInterface<String> stringInterface = new GenericInterfaceImpl<>("Hello");
System.out.println(stringInterface.getValue()); // 输出: Hello
GenericInterface<Integer> intInterface = new GenericInterfaceImpl<>(123);
System.out.println(intInterface.getValue()); // 输出: 123
}
}

复制代码

（5）注意事项

范例擦除：Java 中的泛型是通过范例擦除（Type Erasure）实现的，这意味着在运行时，泛型范例信息会被擦除，以包管与非泛型代码的兼容性。
通配符：可以利用 ? 作为通配符，表现未知范例，常用于泛型方法和泛型类的参数。

// 上界通配符
public static void printNumbers(List<? extends Number> list) {
for (Number number : list) {
System.out.println(number);
}
}
// 下界通配符
public static void addNumbers(List<? super Integer> list) {
list.add(100);
}

复制代码

7. 聚集框架（Collections Framework）

（1）界说

界说：Java 聚集框架（Collections Framework）是一组类和接口，用于存储和操纵一组对象。聚集框架提供了多种数据结构，如列表、聚集、映射等。
利用场景：实用于必要动态存储和管理一组对象的场景。

（2）常用聚集接口和类

List：有序聚集，允许存储重复元素。
- ArrayList：基于数组的实现，支持快速随机访问。

List<String> list = new ArrayList<>();
list.add("A");
list.add("B");
list.add("C");
System.out.println(list.get(0)); // 输出: A

复制代码

LinkedList：基于链表的实现，支持快速的插入和删除操纵。

List<String> list = new LinkedList<>();
list.add("A");
list.add("B");
list.add("C");
System.out.println(list.get(1)); // 输出: B

复制代码

Set：无序聚集，不允许存储重复元素。
- HashSet：基于哈希表的实现，提供常数时间的添加、删除和查找操纵。

Set<String> set = new HashSet<>();
set.add("A");
set.add("B");
set.add("C");
System.out.println(set.contains("A")); // 输出: true

复制代码

TreeSet：基于红黑树的实现，元素按天然序次排序或根据自界说比力器排序。

Set<String> set = new TreeSet<>();
set.add("B");
set.add("A");
set.add("C");
// 输出: [A, B, C] （按自然顺序排序）
System.out.println(set);

复制代码

Map：存储键值对，键必须唯一。
- HashMap：基于哈希表的实现，提供常数时间的添加、删除和查找操纵。

Map<String, Integer> map = new HashMap<>();
map.put("A", 1);
map.put("B", 2);
map.put("C", 3);
System.out.println(map.get("B")); // 输出: 2

复制代码

TreeMap：基于红黑树的实现，键按天然序次排序或根据自界说比力器排序。

Map<String, Integer> map = new TreeMap<>();
map.put("B", 2);
map.put("A", 1);
map.put("C", 3);
// 输出: {A=1, B=2, C=3} （按键的自然顺序排序）
System.out.println(map);

复制代码

（3）常用方法

List 常用方法
- add(E element)：将元素添加到列表末了。
- get(int index)：返回指定索引处的元素。
- remove(int index)：移除指定索引处的元素。
- size()：返回列表中的元素数量。
- contains(Object o)：判断列表是否包罗指定元素。
Set 常用方法
- add(E element)：将元素添加到聚会集。
- contains(Object o)：判断聚集是否包罗指定元素。
- size()：返回聚会集的元素数量。
- remove(Object o)：移除指定元素。
Map 常用方法
- put(K key, V value)：将键值对放入映射中。
- get(Object key)：返回指定键对应的值。
- containsKey(Object key)：判断映射是否包罗指定键。
- keySet()：返回映射中全部键的聚集。
- values()：返回映射中全部值的聚集。
- size()：返回映射中的键值对数量。

（4）注意事项

线程安全：Java 聚集框架中的大多数类都好坏线程安全的。如果必要在多线程情况下利用，可以思量利用同步包装器或并发包中的类，如 Collections.synchronizedXXX 或 ConcurrentHashMap。
性能：差别聚集类的性能特性差别，选择时需根据具体场景衡量。比方，ArrayList 得当随机访问，而 LinkedList 得当频仍插入和删除操纵。
不可变聚集：Java 9 引入了不可变聚集，可以通过 List.of(), Set.of(), Map.of() 等方法创建不可变聚集。

List<String> immutableList = List.of("A", "B", "C");
Set<Integer> immutableSet = Set.of(1, 2, 3);
Map<String, String> immutableMap = Map.of("key1", "value1", "key2", "value2");

复制代码

8. 非常处置惩罚（Exception Handling）

（1）界说

throw new MyCustomException("Something went wrong with the operation on object X");

复制代码

try (FileReader reader = new FileReader("file.txt")) {
// 使用 FileReader 读取文件
} catch (IOException e) {
// 处理异常
}

复制代码

（6）常见的 Java 非常

9. Java 并发（Concurrency）

（1）界说

（2）创建线程

class MyThread extends Thread {
@Override
public void run() {
System.out.println("Thread is running.");
}
}
public class ThreadExample {
public static void main(String[] args) {
MyThread thread = new MyThread();
thread.start(); // 启动新线程
}
}

复制代码

界说：非常处置惩罚是 Java 提供的一种机制，用于处置惩罚步调运行时的错误，以包管步调的坚固性。
利用场景：实用于捕获和处置惩罚运行时错误，如文件未找到、网络毗连失败等。
（2）非常分类
受检非常（Checked Exception）：这些非常在编译时被查抄，必须通过 try-catch 块捕获或在方法署名中通过 throws 声明抛出。常见的受检非常包罗 IOException, SQLException 等。
2. import java.io.FileReader;
3. import java.io.IOException;
5. public class CheckedExceptionExample {
6. public static void main(String[] args) {
7. try {
8. FileReader reader = new FileReader("file.txt");
9. // 其他操作
10. } catch (IOException e) {
11. System.out.println("An error occurred: " + e.getMessage());
12. }
13. }
14. }
复制代码
非受检非常（Unchecked Exception）：这些非常是运行时非常（RuntimeException），在编译时不会逼迫要求处置惩罚。常见的非受检非常包罗 NullPointerException, ArrayIndexOutOfBoundsException, ArithmeticException 等。
2. public class UncheckedExceptionExample {
3. public static void main(String[] args) {
4. try {
5. String str = null;
6. System.out.println(str.length()); // 抛出 NullPointerException
7. } catch (NullPointerException e) {
8. System.out.println("A null pointer exception occurred.");
9. }
10. }
11. }
复制代码
错误（Error）：错误通常表现严厉的体系标题，如 OutOfMemoryError, StackOverflowError 等，一样平常不发起捕获和处置惩罚。
（3）非常处置惩罚机制
try-catch 块：用于捕获和处置惩罚非常。
2. try {
3. // 可能抛出异常的代码
4. } catch (ExceptionType e) {
5. // 处理异常
6. } finally {
7. // 可选的，无论是否发生异常都会执行的代码
8. }
复制代码
try-with-resources：Java 7 引入了 try-with-resources 声明，可以主动关闭实现了 AutoCloseable 接口的资源（如文件、流等），从而制止手动关闭资源。
2. import java.io.FileReader;
3. import java.io.IOException;
5. public class TryWithResourcesExample {
6. public static void main(String[] args) {
7. try (FileReader reader = new FileReader("file.txt")) {
8. // 使用 FileReader 读取文件
9. } catch (IOException e) {
10. System.out.println("An I/O error occurred: " + e.getMessage());
11. }
12. }
13. }
复制代码
throw 和 throws：
- throw：用于显式抛出非常。
2. public class ThrowExample {
3. public static void checkAge(int age) {
4. if (age < 18) {
5. throw new ArithmeticException("Access denied - You must be at least 18 years old.");
6. } else {
7. System.out.println("Access granted.");
8. }
9. }
11. public static void main(String[] args) {
12. checkAge(15); // 抛出 ArithmeticException
13. }
14. }
复制代码
throws：用于方法署名中声明该方法大概抛出的受检非常。
2. import java.io.IOException;
4. public class ThrowsExample {
5. public void readFile(String filePath) throws IOException {
6. // 读取文件的代码可能抛出 IOException
7. throw new IOException("File not found.");
8. }
10. public static void main(String[] args) {
11. try {
12. ThrowsExample example = new ThrowsExample();
13. example.readFile("file.txt");
14. } catch (IOException e) {
15. System.out.println("An error occurred: " + e.getMessage());
16. }
17. }
18. }
复制代码
（4）自界说非常
界说：可以创建自界说非常类，通过继续 Exception 类或其子类（如 RuntimeException）来实现。
2. // 自定义异常类
3. class InvalidAgeException extends Exception {
4. public InvalidAgeException(String message) {
5. super(message);
6. }
7. }
9. public class CustomExceptionExample {
11. // 方法可能抛出自定义异常
12. public static void checkAge(int age) throws InvalidAgeException {
13. if (age < 18) {
14. throw new InvalidAgeException("You must be at least 18 years old.");
15. } else {
16. System.out.println("Access granted.");
17. }
18. }
20. public static void main(String[] args) {
21. try {
22. checkAge(15); // 传入小于18的年龄，抛出异常
23. } catch (InvalidAgeException e) {
24. System.out.println("Caught an exception: " + e.getMessage());
25. }
26. }
27. }
复制代码
在这个例子中，我们界说了一个自界说非常 InvalidAgeException，并在 checkAge 方法中根据条件抛出该非常。在 main 方法中通过 try-catch 块捕获并处置惩罚这个非常。
（5）非常处置惩罚的最佳实践
只管具体：捕获非常时，只管指定具体的非常范例，而不是直接捕获 Exception。如允许以更好地处置惩罚差别范例的非常。
2. try {
3. // 可能抛出多种异常的代码
4. } catch (NullPointerException e) {
5. // 处理空指针异常
6. } catch (IOException e) {
7. // 处理IO异常
8. }
复制代码
不要忽略非常：纵然在 catch 块中不做太多处置惩罚，至少应该记载非常信息。
2. try {
3. // 可能抛出异常的代码
4. } catch (Exception e) {
5. e.printStackTrace(); // 至少记录异常日志
6. }
复制代码
制止太过利用受检非常：太过利用受检非常大概会导致代码冗余，发起只在须要时利用。
利用具体的非常信息：在抛出自界说非常或任何非常时，提供具体的信息可以资助调试和标题定位。
整理资源：利用 try-with-resources 或在 finally 块中整理资源，确保纵然在发生非常时也能精确开释资源。
不要利用非常来控制流程：非常应该用于处置惩罚错误情况，而不是用于正常的控制流。比方，不要利用非常来代替简单的 if-else 判断。
NullPointerException：试图在 null 对象上调用方法或访问字段时抛出。
ArrayIndexOutOfBoundsException：数组访问超出边界时抛出。
ArithmeticException：算术运算非常，如除以零时抛出。
ClassNotFoundException：当 JVM 找不到指定的类时抛出。
IOException：输入输出操纵失败时抛出。
SQLException：与数据库操纵相干的非常。
IllegalArgumentException：方法吸取到非法参数时抛出。
界说：Java 并发是指在 Java 步调中同时实验多个使命的本领。Java 提供了丰富的并发 API，以支持多线程编程。
利用场景：实用于必要同时处置惩罚多个使命的场景，如服务器处置惩罚多个客户端哀求、并行盘算等。
继续 Thread 类：通过继续 Thread 类并重写 run 方法来创建线程。

实现 Runnable 接口：通过实现 Runnable 接口并转达给 Thread 类来创建线程，这种方式比继续 Thread 更机动，由于 Java 不支持多继续。

class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("Runnable is running.");
}
}
public class RunnableExample {
public static void main(String[] args) {
MyRunnable runnable = new MyRunnable();
Thread thread = new Thread(runnable);
thread.start(); // 启动新线程
}
}

复制代码

Lambda 表达式（Java 8+）：如果利用的是 Java 8 及以上版本，可以通过 Lambda 表达式简化 Runnable 的实现。

public class LambdaThreadExample {
public static void main(String[] args) {
Thread thread = new Thread(() -> {
System.out.println("Lambda Runnable is running.");
});
thread.start(); // 启动新线程
}
}

复制代码

（3）线程的生命周期

线程的生命周期包罗以下几种状态：

New：线程被创建但尚未启动。
Runnable：线程正在 Java 假造机中实验。
Blocked：线程期待监视器锁以进入或重新进入同步块/方法。
Waiting：线程期待另一个线程实验特定操纵。
Timed Waiting：线程期待另一个线程实验特定操纵到达指定时间。
Terminated：线程实验完毕或因非常退出。

可以通过 Thread.getState() 方法获取线程的状态。

public class ThreadStateExample {
public static void main(String[] args) {
Thread thread = new Thread(() -> {
try {
Thread.sleep(2000); // 模拟一些工作
} catch (InterruptedException e) {
e.printStackTrace();
}
});
System.out.println("Before start: " + thread.getState()); // 输出: NEW
thread.start();
System.out.println("After start: " + thread.getState()); // 输出: RUNNABLE
try {
Thread.sleep(1000); // 主线程休眠1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("After 1 second: " + thread.getState()); // 可能输出: TIMED_WAITING 或 RUNNABLE
try {
thread.join(); // 主线程等待子线程结束
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("After completion: " + thread.getState()); // 输出: TERMINATED
}
}

复制代码

（4）线程同步

synchronized 关键字：用于办理多个线程访问共享资源时的竞态条件标题。

public class SynchronizedExample {
private int count = 0;
// synchronized 方法
public synchronized void increment() {
count++;
}
public int getCount() {
return count;
}
public static void main(String[] args) {
SynchronizedExample example = new SynchronizedExample();
Thread t1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
example.increment();
}
});
Thread t2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
example.increment();
}
});
t1.start();
t2.start();
try {
t1.join();
t2.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Final count: " + example.getCount()); // 输出: 20000
}
}

复制代码

认识Java常用变量范例对于Java开发者来说至关告急。这些变量范例包罗根本数据范例（如int、float、boolean）和引用范例（如String、数组）。把握这些范例不但有助于编写更精确、更高效的代码，还能进步步调的可靠性和可维护性
盼望你喜好这篇文章！请点关注和收藏吧。你的关注和收藏会是我积极更新的动力，祝关注和收藏的帅哥玉人们本年都能暴富。如果有更多标题，接待随时提问

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金

(超等具体版)Java根本:Java常用变量详解

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

九天猎人