【JavaSE成神之路】一文洞悉Java语言的基本语法-CFANZ编程社区

哈喽，我是兔哥，今天就让我们继续这个JavaSE成神之路！

这一节，咱们要学习的内容是Java语言的基本语法，包括变量、常量、数据类型、运算符、流程控制语句、数组、字符串。

这是我们学好Java的基石，万丈高楼平地起的前提就是打好地基。

下面就让我们来一一参悟这些概念吧。

1. 变量和常量：Java中的变量用于存储程序运行过程中的数据，常量则用于存储固定不变的值。

例如：

// 定义一个整型变量x，并赋值为10
int x = 10;

// 定义一个常量PI，并赋值为3.14
final double PI = 3.14;

2. 数据类型：Java中的数据类型用于指定变量或常量存储的数据类型，Java提供了多种基本数据类型和引用数据类型。

例如：

// 定义一个整型变量x
int x;

// 定义一个字符串变量name
String name;

java有8种基本数据类型，具体是哪8种呢？

Java是一种面向对象的编程语言，它支持多种基本数据类型。例如，整型数据类型包括byte、short、int和long，其中int是最常用的。浮点型数据类型包括float和double，其中double精度更高。还有字符型数据类型char和布尔型数据类型boolean。

举个例子，下面是一个简单的Java程序，它声明了一个int类型的变量x并将值赋为10：

public class MyClass {
  public static void main(String[] args) {
    int x = 10;
  }
}

在这段代码中，int是一个Java关键字，它用于声明一个整型变量。这个变量可以存储任何整数值，例如10、-5或100。

需要注意的是，Java中的基本数据类型都有固定的大小，因此它们能存储的数值范围也是有限的。例如，int类型的变量可以存储的整数值的范围为-2147483648到2147483647。如果需要存储更大或更小的整数值，就需要使用其它数据类型，例如long。

至于引用类型，Java中的引用类型是指由用户定义的数据类型，它通过类来定义，通过对象来使用。引用类型可以描述复杂的数据结构，比如链表、树、图等。

例如：

// 定义一个类Person
class Person {
    // 定义类的属性
    String name;
    int age;
    boolean gender;

    // 定义类的方法
    void sayHello() {
        System.out.println("Hello, I'm " + name);
    }
}

// 使用类Person定义一个对象alice
Person alice = new Person();

// 使用对象alice的属性
alice.name = "Alice";
alice.age = 18;
alice.gender = true;

// 使用对象alice的方法
alice.sayHello();

上述代码中，定义了一个类Person，该类包含了name、age、gender三个属性和一个sayHello方法。然后，使用该类定义了一个对象alice，并对对象的属性和方法进行了操作。

总之，Java中的基本数据类型是Java语言内置的数据类型，用于存储基本的数据；而引用类型则是用户定义的数据类型，用于存储复杂的数据结构。

很多小伙伴可能会纠结基本数据类型和引用类型的区别，可以参考以下的说明哈：

Java中的引用数据类型指的是类和接口。它们与基本数据类型（例如 int 和 double）不同，因为它们不存储值，而是存储对象的引用。

使用引用数据类型时，有几点需要注意：

在 Java 中，所有的引用类型都默认初始化为 null。所以，在使用一个引用变量之前，你需要先创建一个新的对象并将其赋值给该变量。
在 Java 中，不能使用运算符 “==” 来比较两个引用类型的值。这是因为 “==” 运算符比较的是两个引用类型的地址，而不是它们所引用的对象的值。如果你想比较两个引用类型的值，你需要使用equals()方法。
在 Java 中，不能把一个引用类型的变量直接赋值给另一个引用类型的变量。这是因为 Java 是一种静态类型语言，它的类型系统非常严格。所以，如果你想把一个引用类型的变量赋值给另一个引用类型的变量，你需要显式地进行类型转换。

3. 运算符：Java中的运算符用于对变量或常量进行操作，Java提供了算术运算符、关系运算符、逻辑运算符、位运算符等。

快速入门：

// 定义两个整型变量x和y，并赋值为10和20
int x = 10, y = 20;

// 计算x+y的值
int z = x + y;

// 判断x是否大于y
boolean b = x > y;

Java的算术运算符

算术运算符包括“+”（加法）、“-”（减法）、“*”（乘法）、“/”（除法）、“%”（取模）和“++”、“--”（自增和自减）。下面是一些简单的例子，演示了这些运算符的用法：

int a = 10;
int b = 20;
int c = 30;
 
// 加法运算
int d = a + b;  // d = 30
 
// 减法运算
int e = b - a;  // e = 10
 
// 乘法运算
int f = a * b;  // f = 200
 
// 除法运算
int g = b / a;  // g = 2
 
// 取模运算
int h = c % a;  // h = 0
 
// 自增运算
int i = a++;    // i = 10, a = 11
 
// 自减运算
int j = b--;    // j = 20, b = 19

需要注意的是，Java 中的除法运算符“/”是两个整数相除，只保留整数部分。如果你想保留小数部分，你需要把其中一个操作数转换为浮点数：

// 两个整数相除，只保留整数部分
int k = b / a;  // k = 2
 
// 两个整数相除，保留小数部分
double l = b / (double)a;  // l = 2.0

另外，Java 中的取模运算符 “%” 是两个整数相除，返回余数。如果你想求出商，你可以使用整除运算符 “/” 和取模运算符

我们工作中经常会用到的，除了算数运算符，还有逻辑运算符。

逻辑运算符

Java支持多种逻辑运算符，它们用于比较两个值并返回一个布尔值（即true或false）。下面是Java中常用的逻辑运算符：

&&：逻辑与运算符。如果两个操作数都是true，则返回true，否则返回false。
||：逻辑或运算符。如果两个操作数中有一个是true，则返回true，否则返回false。
!：逻辑非运算符。如果操作数为true，则返回false；如果操作数为false，则返回true。

下面是一个简单的Java程序，它使用逻辑运算符来比较两个整型变量x和y：

public class MyClass {
  public static void main(String[] args) {
    int x = 5;
    int y = 10;

    // 如果x大于0且y小于20，则输出true
    System.out.println(x > 0 && y < 20);  // 输出true

    // 如果x等于5或y等于10，则输出true
    System.out.println(x == 5 || y == 10);  // 输出true

    // 如果x不等于5，则输出true
    System.out.println(!(x == 5));  // 输出false
  }
}

关系运算符

Java中的关系运算符用于比较两个值的大小关系。Java中的关系运算符包括“>”（大于）、“>=”（大于等于）、“<”（小于）、“<=”（小于等于）、“==”（等于）和“!=”（不等于）。下面是一些例子，演示了这些运算符的用法：

int a = 10;
int b = 20;
 
// 大于运算
if (a > b) {
  // 如果 a 大于 b，执行某些操作
}
 
// 大于等于运算
if (a >= b) {
  // 如果 a 大于等于 b，执行某些操作
}
 
// 小于运算
if (a < b) {
  // 如果 a 小于 b，执行某些操作
}
 
// 小于等于运算
if (a <= b) {
  // 如果 a 小于等于 b，执行某些操作
}
 
// 等于运算
if (a == b) {
  // 如果 a 等于 b，执行某些操作
}
 
// 不等于运算
if (a != b) {
  // 如果 a 不等于 b，执行某些操作
}

4. 流程控制语句：Java中的流程控制语句用于控制程序的执行流程，Java提供了if-else、switch-case、while、do-while、for等语句。

例如：

// 定义一个整型变量x，并赋值为10
int x = 10;

// 使用if-else语句判断x的值
if (x > 0) {
    System.out.println("x is positive");
} else if (x < 0) {
    System.out.println("x is negative");
} else {
    System.out.println("x is zero");
}

// 使用while语句计算1到10的和
int sum = 0;
int i = 1;
while (i <= 10) {
    sum += i;
    i++;
}
System.out.println("The sum is " + sum);

5. 数组：Java中的数组用于存储多个相同类型的数据，Java提供了一维数组和多维数组。

例如：

Java数组是由相同类型的一组连续的数据组成的有序集合。数组元素可以是基本数据类型（如int、double等），也可以是引用类型（如String、Object等）。

在Java中，数组定义的语法格式如下：

类型[] 数组名 = new 类型[长度];

例如，定义一个长度为10的int型数组，可以这样写：

int[] numbers = new int[10];

定义数组后，数组中的每个元素都会被自动初始化为默认值，例如int型数组的默认值为0。

Java 8及更高版本提供了一种简化的数组初始化语法，可以在定义数组的同时直接指定数组元素的值。例如，定义一个长度为5的int型数组，并将每个元素都初始化为1，可以这样写：

int[] numbers = {1, 1, 1, 1, 1};

在 Java 中，数组可以在创建时进行初始化和赋值。

例如，下面的代码创建了一个长度为 5 的整型数组，并在创建时初始化了它的每个元素：

int[] array = {1, 2, 3, 4, 5};

您也可以在创建数组后，通过索引来单独赋值每个元素，例如：

int[] array = new int[5];
array[0] = 1;
array[1] = 2;
array[2] = 3;
array[3] = 4;
array[4] = 5;

拓展，用数组完成冒泡排序算法：下面是一个简单的Java程序，它实现了冒泡排序算法：

public class MyClass {
  public static void main(String[] args) {
    int[] arr = {5, 2, 4, 6, 1, 3};

    // 对数组进行冒泡排序
    for (int i = 0; i < arr.length - 1; i++) {
      for (int j = 0; j < arr.length - 1 - i; j++) {
        if (arr[j] > arr[j + 1]) {
          // 交换arr[j]和arr[j + 1]的值
          int temp = arr[j];
          arr[j] = arr[j + 1];
          arr[j + 1] = temp;
        }
      }
    }

    // 输出排序后的数组
    for (int i = 0; i < arr.length; i++) {
      System.out.print(arr[i] + " ");
    }
  }
}

在这段代码中，第3行创建了一个名为arr的整型数组，它包含6个元素。第6至18行实现了冒泡排序算法，它通过两重循环来对数组进行排序。第12行至第15行使用了一个临时变量temp来交换两个数的值，以实现排序。第20至26行则用了一个单独的循环来输出排序后的数组。

如果运行这段代码，它会输出以下结果：

1 2 3 4 5 6

6. 字符串：Java中的字符串表示文本数据，Java提供了String类来操作字符串。

例如：

// 定义一个字符串变量str，并赋值为"Hello, World!"
String str = "Hello, World!";

// 获取字符串的长度
int len = str.length();

// 获取字符串的第2个字符
char c = str.charAt(1);

// 获取字符串的子串
String sub = str.substring(7, 12);

// 把字符串转换为大写
String upper = str.toUpperCase();

上述代码中，使用了String类的length、charAt、substring、toUpperCase等方法来操作字符串。

关于字符串这个引用数据类型，有太多可以讲的东西了，它也是我们工作中最常用的对象，不过目前我们就先简单了解一下即可。

【JavaSE成神之路】一文洞悉Java语言的基本语法_链表