Java语言基础

Java是一种面向对象、跨平台的编程语言，广泛应用于Web开发、移动应用、企业应用等领域。本文将介绍Java语言的基本语法，包括变量和数据类型、运算符、控制语句、数组等内容。

变量和数据类型

变量是程序中的一种占位符，用来存储某种数据类型的值。Java中的变量需要先声明再使用，声明语法为：数据类型 变量名；例如：

int age; // 声明一个整型变量age

这里，int是数据类型，age是变量名。Java中的数据类型可分为两类：基本数据类型和引用数据类型。基本数据类型包括整型、浮点型、布尔型和字符型，引用数据类型包括类、接口、数组等。

Java中的变量类型可以分为如下几种：

• 局部变量：在方法、构造器或块中定义的变量，只在方法、构造器、块执行时存在。必须先声明再使用，否则会引发编译错误。
• 类变量/静态变量：使用static关键字定义的变量，位于类体中，可被类的所有对象共享。
• 成员变量/实例变量：不使用static关键字定义的变量，定义在类体中，只能被同一类的对象共享。

Java中的变量名必须符合标识符规则，即只能由字母、数字、下划线和美元符号组成，且不能以数字开头。变量名也应该遵循驼峰命名法。

Java中的数据类型包括以下几种：

基本数据类型

整型

在Java中，整型可分为4种：byte、short、int和long，它们分别占用1、2、4和8个字节，表示不同的数值范围。在声明整型变量时，应该根据实际需求来选择合适的类型，避免浪费内存空间。

byte b = 100; // 声明一个byte型变量b，赋值为100
short s = 1000; // 声明一个short型变量s，赋值为1000
int i = 100000; // 声明一个int型变量i，赋值为100000
long l = 10000000000L; // 声明一个long型变量l，赋值为10000000000，注意需在数字后加上"L"或"l"

浮点型

在Java中，浮点型可分为2种：float和double，它们分别占用4和8个字节，表示不同的数值精度。在声明浮点型变量时，应该选择合适的类型，避免浪费内存空间。

float f = 3.14f; // 声明一个float型变量f，赋值为3.14，注意需在数字后加上"f"或"F"
double d = 3.1415926; // 声明一个double型变量d，赋值为3.1415926

字符型

在Java中，字符型可占用2个字节，表示Unicode字符集中的一个字符。在声明字符型变量时，应该使用单引号。

char c = 'A'; // 声明一个字符型变量c，赋值为'A'

布尔型

在Java中，布尔型只有两个取值：true和false。在声明布尔型变量时，应该选择合适的类型。

boolean flag = true; // 声明一个布尔型变量flag，赋值为true

### 引用数据类型

Java中的引用数据类型包括类、接口、数组等。在声明引用数据类型变量时，需要使用对应数据类型的类或接口名作为变量类型。例如：

```java
String str = "Hello, Java!"; // 声明一个字符串变量str，赋值为"Hello, Java!"

此处，str是一个引用数据类型变量，其类型为String类。

Java中的变量有一些特殊的取值，包括null和NaN。

null

null表示变量的值为null，即空值，常用于判断变量是否为空。例如：

String str = null;
if (str == null) {
    System.out.println("str is null.");
}

此处，str的值为null，因此if语句中的条件为true，输出结果为"str is null."。

NaN

NaN表示一个非数值（Not a Number），常用于浮点型计算时的错误处理。例如：

double d1 = 0.0 / 0.0; // 计算0.0/0.0
double d2 = Double.NaN; // 声明一个非数值类型的变量d2，赋值为NaN
if (Double.isNaN(d1)) {
    System.out.println("d1 is NaN.");
}
if (Double.isNaN(d2)) {
    System.out.println("d2 is NaN.");
}

此处，d1和d2均为NaN，因此两个if语句中的条件均为true，输出结果为"d1 is NaN.“和"d2 is NaN.”。

数组

数组是Java中最常见的数据结构之一，可以存储多个同类型的数据。数组可以通过下标来快速访问其元素，因此也被称为随机访问数据结构。

在Java中，数组的声明和初始化可以通过以下语句完成：

int[] a; // 声明一个整型数组
a = new int[5]; // 初始化a数组为长度为5的整型数组

也可以将声明和初始化合并为一句：

int[] a = new int[5]; // 声明并初始化一个长度为5的整型数组

数组也可以进行初始化时直接赋值：

int[] a = {1, 2, 3, 4, 5}; // 声明并初始化一个包含了5个元素的整型数组

或者使用数组的静态初始化语法：

int[] a = new int[]{1, 2, 3, 4, 5}; // 声明并初始化一个包含了5个元素的整型数组

数组的元素可以通过下标进行访问：

int second = a[1]; // 获取数组a的第二个元素，即2
a[2] = 100; // 将数组a的第三个元素设置为100

Java还提供了一个方便的方法来获取数组的长度：

int len = a.length; // 获取数组a的长度，即5

运算符

Java中的运算符包括算术运算符、关系运算符、逻辑运算符、位运算符等。下面是一些常用的运算符。

算术运算符

Java中的算术运算符包括加、减、乘、除、取模等。例如：

int a = 10;
int b = 20;
int c = a + b; // a和b的和
int d = a - b; // a和b的差
int e = a * b; // a和b的积
int f = a / b; // a和b的商
int g = a % b; // a除以b的余数

注意，在Java中，整数相除，结果会取整，因此f的值为0。如果想得到小数，可以将其中一个操作数强制转换为浮点数。例如：

double f = (double)a / b;

关系运算符

Java中的关系运算符用于判断两个值之间的关系，包括小于、大于、等于、不等于等。例如：

int a = 10;
int b = 20;
boolean c = a < b; // 判断a是否小于b
boolean d = a > b; // 判断a是否大于b
boolean e = a <= b; // 判断a是否小于等于b
boolean f = a >= b; // 判断a是否大于等于b
boolean g = a == b; // 判断a是否等于b
boolean h = a != b; // 判断a是否不等于b

逻辑运算符

Java中的逻辑运算符用于处理布尔型变量，包括与、或、非等。例如：

boolean a = true;
boolean b = false;
boolean c = a && b; // a和b的逻辑与，结果为false
boolean d = a || b; // a和b的逻辑或，结果为true
boolean e = !a; // a的逻辑非，结果为false

位运算符

Java中的位运算符用于处理二进制数据，包括按位与、按位或、按位异或等。例如：

int a = 5; // 二进制为101
int b = 3; // 二进制为011
int c = a & b; // a和b的按位与，结果为1
int d = a | b; // a和b的按位或，结果为7
int e = a ^ b; // a和b的按位异或，结果为6
int f = ~a; // a的按位非，结果为-6

三目运算符

Java中的三目运算符，也称为条件运算符，是一种简洁的条件语句。它的语法如下：

表达式1 ? 表达式2 : 表达式3

只需根据表达式1的值来判断执行表达式2或表达式3。例如：

int a = 10;
int b = 20;
int c = (a > b) ? a : b; // 如果a>b则返回a，否则返回b

自增与自减运算符

Java中的自增（++）和自减（–）运算符都是一元运算符，用于自增或自减一个变量的值。它们可以用在表达式中，也可以用在单独语句中。

int a = 5;
a++; // a自增1，等价于a = a + 1;
int b = 10;
b--; // b自减1，等价于b = b - 1;

注意，在简单赋值语句中，自增和自减运算符可以放在变量的前面或后面，但两种方式的执行顺序不同，因此结果也不同。例如：

int a = 5;
int b, c;
b = a++; // 先将a的值赋给b，再将a自增1，b的值为5，a的值为6
c = ++a; // 先将a自增1，再将a的值赋给c，a和c的值都为7

控制语句

Java中的控制语句用于控制程序的流程，包括条件语句、循环语句、跳转语句等。下面是一些常用的控制语句。

条件语句

Java中的条件语句包括if语句、switch语句等。

if语句用于判断一个条件，然后执行对应的语句。它的语法如下：

if (condition) {
    // 如果condition为true，则执行这里的语句
} else {
    // 如果condition为false，则执行这里的语句
}

其中，condition是一个布尔型表达式。如果condition为true，则执行if语句块中的语句；如果condition为false，则执行else语句块中的语句。

例如：

int a = 10;
int b = 20;
if (a > b) {
    System.out.println("a > b");
} else if (a == b) {
    System.out.println("a == b");
} else {
    System.out.println("a < b");
}

这里，a的值为10，b的值为20，因此程序输出结果为"a < b"。

switch语句用于根据变量的不同取值执行不同的语句。它的语法如下：

switch (variable) {
    case value1:
        // 如果variable的值为value1，则执行这里的语句
        break;
    case value2:
        // 如果variable的值为value2，则执行这里的语句
        break;
    ...
    default:
        // 上述所有情况都不满足时，则执行这里的语句
}

其中，variable是一个变量名，后面根据变量的不同取值执行不同的case语句，如果遇到break语句，则跳出switch语句。

例如：

int a = 2;
switch (a) {
    case 1:
        System.out.println("a = 1");
        break;
    case 2:
        System.out.println("a = 2");
        break;
    case 3:
        System.out.println("a = 3");
        break;
    default:
        System.out.println("a is not 1, 2, or 3");
}

这里，a的值为2，因此程序输出结果为"a = 2"。

循环语句

Java中的循环语句包括for循环、while循环、do-while循环等。

for循环用于执行一组语句，重复指定的次数。它的语法如下：

for (初始表达式; 条件表达式; 循环后操作表达式) {
    // 执行循环体的语句
}

其中，初始表达式是在执行循环之前执行的，通常用于初始化计数器或定义循环变量；条件表达式在每次循环之前都会被求值，如果结果为true，则执行循环体中的语句，否则退出循环；循环后操作表达式则在每次循环之后执行，通常用于更新计数器或循环变量。

例如：

for (int i = 0; i < 10; i++) {
    System.out.println(i);
}

这里，循环体中的语句会被执行10次，每次输出一个整数i，从0开始到9结束。

while循环用于执行一组语句，直到条件变为false为止。它的语法如下：

while (condition) {
    // 执行循环体的语句
}

其中，condition是一个布尔型表达式。只要condition为true，则循环会一直执行，直到condition变为false为止。

例如：

int i = 0;
while (i < 10) {
    System.out.println(i);
    i++;
}

这里，循环体中的语句会被执行10次，每次输出一个整数i，从0开始到9结束。

do-while循环与while循环类似，但条件判断发生在循环体之后。它的语法如下：

do {
    // 执行循环体的语句
} while (condition);

其中，condition是一个布尔型表达式。先执行循环体中的语句，再判断condition的值，只要condition为true，则继续循环，直到condition变为false为止。

例如：

int i = 0;
do {
    System.out.println(i);
    i++;
} while (i < 10);

这里，循环体中的语句会被执行10次，每次输出一个整数i，从0开始到9结束。

跳转语句

Java中的跳转语句包括break语句、continue语句和return语句等。

break语句用于跳出当前循环。它的语法如下：

break;

例如：

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // 当i=5时跳出循环
    }
    System.out.println(i);
}

这里，循环体中的语句会被执行5次，每次输出一个整数i，从0开始到4结束。

continue语句用于跳过当前循环的剩余部分，开始下一次循环。它的语法如下：

continue;

例如：

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        continue; // 当i=5时跳过循环的剩余部分，开始下一次循环
    }
    System.out.println(i);
}

这里，循环体中的语句会被执行9次，每次输出一个整数i，从0开始到9结束，但当i=5的时候，输出会被跳过。

return语句用于退出一个方法，并返回一个值（如果有的话）。它的语法如下：

return value;

其中，value是方法的返回值，可以是任意类型。

例如：

public int add(int a, int b) {
    return a + b; // 返回a和b的和
}

这里，add方法的返回值是a和b的和。

异常处理

Java中的异常处理机制用于处理程序中出现的异常情况，并提供了一种统一的方式来处理异常。当一个异常被抛出时，Java程序会沿着调用栈向上查找匹配的异常处理器。

Java中的异常分为两种：受检异常（Checked Exception）和非受检异常（Unchecked Exception）。

受检异常是在编译时就能检查出来的异常，必须在方法上显式声明或捕获并处理，否则编译将不通过。受检异常通常包括IOException、SQLException等等。

非受检异常是在运行时才能发现的异常，通常由程序员编码错误引起，也可能由Java虚拟机错误引起。非受检异常通常包括NullPointerException、ArrayIndexOutOfBoundsException、ClassCastException等等。

Java中的异常处理语句包括try语句块、catch语句块和finally语句块。try语句块包含需要检测异常的代码，如果出现异常，则控制将转移到一个catch语句块中，catch语句块可以处理异常或将它传递给调用者。finally语句块包含代码，它始终会被执行，无论是正常情况下还是异常情况下。

例如：

try {
    // 执行需要检测异常的代码
} catch (ExceptionType1 ex1) {
    // 处理ExceptionType1类型的异常
} catch (ExceptionType2 ex2) {
    // 处理ExceptionType2类型的异常
} finally {
    // 始终会被执行的代码
}

这里，try语句块中包含需要检测异常的代码，可以包含多个catch语句块来处理不同类型的异常。finally语句块中的代码始终会被执行，无论是正常情况下还是异常情况下。

抛出异常

Java中的异常处理机制还包括抛出异常的语句，即throw语句。当程序发现某种错误情况时，可以主动抛出一个异常。抛出一个异常后，程序会在调用栈中查找匹配的异常处理器，如果找到了匹配的异常处理器，则将控制传递给处理器中的catch语句块，如果没有找到匹配的异常处理器，则程序会终止执行并打印异常堆栈的跟踪信息。

if (errorCondition) {
    throw new Exception("Error message.");
}

这里，如果errorCondition为true，则程序会抛出一个异常，异常的消息为"Error message."。

实例演示

下面是一个简单的Java程序示例，演示了Java中的变量、运算符、控制语句和异常处理等基本知识点。

public class HelloWorld {
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        int c = add(a, b);
        System.out.println("a + b = " + c);
        try {
            int d = divide(a, 0);
            System.out.println("a / 0 = " + d);
        } catch (ArithmeticException ex) {
            System.out.println("Cannot divide by zero.");
        }
    }
    
    public static int add(int a, int b) {
        return a + b;
    }
    
    public static int divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException();
        }
        return a / b;
    }
}

这个程序先定义了两个整数变量a和b，然后使用add方法计算它们的和。接着，使用try-catch语句块尝试将a除以0，但由于除数为0，程序会抛出一个ArithmeticException异常，被catch语句块捕获并打印出错误信息"Cannot divide by zero."。最后，程序输出a和b的和，结果为30。