Java SE篇：Java 基础语法

约定不等于承诺〃 2024-03-16 19:07 15阅读 0赞

> 代码的五大组成部分：注释、关键字、标识符、数据、符号。

### Java语法组成 ###

#### 注释 ####

注释是在程序**指定位置** 添加的**说明性信息** 简单理解，就是对代码的一种解释。

> 注意事项：注释内容不会参与编译和运行。

*  单行注释：单行注释通常用于解释方法内某单行代码的作用。通常写在本段代码的上方。

`plain 格式：// 注释信息`

*  多行注释：多行注释使用的频率其实并不高，通常用于解释一段代码的作用。

`plain 格式：/* 注释信息 */`

*  文档注释：文档注释可用在三个地方，类、字段和方法，用来解释它们是干嘛的。

`java 格式：/** 注释信息 */`

#### 关键字 ####

*  **关键字概念** :被Java赋予了特定涵义的英文单词。
 *  **关键字特点** :关键字的字母**全部小写** 。

> 分析：main是关键字吗?
> 
> 答:main不是关键字，可以将其理解为，比关键字更为关键的一个单词，因为JVM在执行代码的时候，只会识别该单词。

#### 标识符 ####

> **标识符概念** ：就是给类，方法，变量等起名字的 符号

**标识符定义规则 ：**

*  1.标识符以由大小写字母、数字、下划线(\_)和美元符号(\\$)组成，但是不能以数字开头。
 *  2.不能以数字开头。
 *  3.不能是关键字。
 *  4.区分大小写。
 *  5.不能有空格、@、\#、+、-、/ 等符号
 *  6.应该使用有意义的名称，达到见名知意的目的，最好以小写字母开头

**常见命名约定** ：

*  **1.小驼峰： 方法、变量。**
    
     *  约定1：标识符是一个单词的时候，首字母小写 范例1：name
     *  约定2：标识符由多个单词组成的时候，第一个单词首字母小写，其他单词首字母大写

范例2：firstName

*  **2.大驼峰：类、接口。**
    
     *  约定1：标识符是一个单词的时候，首字母大写
        
        范例1： Student
     *  约定2：标识符由多个单词组成的时候，每个单词的首字母大写
        
        范例2：GoodStudent
 *  **3.峡谷先锋：常量名。**
    
     *  范例：final int JAVA\_HOME = 10;

#### 数据 ####

##### 常量 #####

> 常量概念：在程序的执行过程中，其值不会发生改变的量(数据)

*  其中空常量`null`是用来占位的，不能直接打印(会报错)。
 *  也可以用8进制和16进制表示一个常量值

##### 变量 #####

> 变量概念：变量就是内存中的存储空间，空间中存储着经常发生改变的量(数据)

*  定义格式：数据类型 变量名 = 常量数据;
 *  **变量的使用** ： 1、声明变量，就是在内存开一个空间 语法：数据类型 变量名;(空格和分号不能少)，比如：int qian; 2、变量赋值，就是将数据放到开辟的这个空间 语法：变量名 = 变量值;比如：qian = 1000; 3、使用变量    比如：System.out.println(qian);

`java int a = 10; int b = 20; int c = (a = b); System.out.println(c); //20 意思是把b先赋值给a,10就被20给覆盖了。`

**变量的注意事项** ：

1.  使用之前必须先赋值
2.  同一个范围内 不能重复定义相同名字的变量
3.  变量可以连续定义
4.  变量只在当前\{\}的范围内有效。
5.  long类型后面要加L float后面要加 F
    
     *  变量的作用域：作用域从变量定义的位置开始，到该变量所在的那对大括号结束；
     *  生命周期：变量从定义的位置开始就在内存中活了；变量到达它所在的作用域的时候就在内存中消失了；

### 数据类型 ###

Java语言是强类型语言，对于每一种数据都给出了明确的数据类型，不同的**数据类型** 也分配了不同的**内存空间** 所以它们表示的**数据大小** 也是不一样的。

![img][]

数据类型内存占用和取值范围：

![img][img 1]

> 范围的大小顺序：byte < short =char < int \\

*  在网络传输的过程中，为了节省空间，常用字节来作为数据的传输方式。
 *  为了和 int 作区分，long 型变量在声明的时候，末尾要带上大写的“L”。(因为默认情况下整数默认为int类型)

> 对于很长的数字，为了提升辨识度，我们可以使用下划线去分割每一位 。和原本的内容没有区别,效果是一样的，只是为了增加辨识度。如：1\_000\_000\_000

*  为了和 double 作区分，float 型变量在声明的时候，末尾要带上小写的“f”。不需要使用大写的“F”，是因为小写的“f”很容易辨别。
 *  double 同样不适合用于精确的数值，比如说货币,最好使用 BigDecimal。
 *  char 既然只有一个字符，为什么占 2 个字节呢？
    
     *  主要是因为 Java 使用的是 Unicode 字符集而不是 ASCII 字符集。

> 注意：小数类型和整数类型一样，小数常量默认类型都是double类型，所以说，表示float时候在后面加一个f

**为什么数组也是引用类型呢？**

下面这段代码：

`java public class ArrayDemo { public static void main(String[] args) { int [] arrays = {1,2,3}; System.out.println(arrays); } }`

arrays 是一个 int 类型的数组打印结果如下所示：

`plain [I@2d209079`

> `[I` 表示数组是 int 类型的，@ 后面是十六进制的 hashCode——这样的打印结果太“人性化”了，一般人表示看不懂！为什么会这样显示呢？查看一下 `java.lang.Object` 类的 `toString()` 方法就明白了。

数组虽然没有显式定义成一个类，但它的确是一个对象，继承了祖先类 Object 的所有方法。那为什么数组不单独定义一个类来表示呢？就像字符串 String 类那样呢？

一个合理的解释是 Java 将其隐藏了。假如真的存在一个 Array.java，我们也可以假想它真实的样子，它必须要定义一个容器来存放数组的元素，就像 String 类那样。

`java public final class String implements java.io.Serializable, Comparable<String>, CharSequence { /** The value is used for character storage. */ private final char value[]; }`

**为什么接口是引用类型？**

> 对于接口类型的引用变量来说，你没法直接 new 一个：
> 
> 只能 new 一个实现它的类的对象——那自然接口也是引用数据类型了。

来看一下基本数据类型和引用数据类型之间最大的差别。

*  基本数据类型： 1、变量名指向具体的数值。 2、基本数据类型存储在栈上。
 *  引用数据类型： 1、变量名指向的是存储对象的内存地址，在栈上。 2、内存地址指向的对象存储在堆上。

### 数据类型转换 ###

#### 隐式类型转换 ####

> 规则： 是从小范围的数据类型 直接转到 大范围的数据类型

范围的排序:byte < short = char < int < long < float < double

> 实际上，我们在将小的整数类型传递给大的整数类型时，也发生了隐式类型转换、比如传递一个常量10 ，实际上默认情况下是int类型，但是由于正好对应类型在可以表示的范围内。所以说直接转换为了byte类型的值。

**运用规则**：

1.  比int大(或者等于)的类型， 在进行运算的时候， 小类型会自动提升为大类型进运算
2.  ：比int小的数据类型， 在进行运算的时候，所有的都要提升为 int类型 再去运算。

#### 强制类型转换 ####

> 规则：是从大范围的数据类型 强制转到 小范围的数据类型

\*\*强制类型转换的注意事项：\*\*boolean类型 不参与任何的类型转换.

**常量优化机制:**

1.比int小的类型 才有常量优化机制:byte、short、char int 2.写一个整数常量的时候， 整数常量也是有数据类型的， int类型 3.写一个小数常量的时候，小数常量也是有数据类型的， double类型。

\`\`\`java 问题疑问：byte d = 3 + 4; 为什么不会出现错误？

public class Test \{  
public static void main(String\[\] args) \{  
byte d = 3 + 4;  
\}  
\}  
因为3和4，是两个常量，Java中存在【常量优化机制】

常量优化机制：在编译时(javac)，就会将3和4计算出一个7的结果，并且会自动判断该结果是否在byte取值范围内。  
在：编译通过  
不在：编译失败

long类型的数据后面 为什么要加L？

class Demo \{  
public static void main(String\[\] args)\{  
int a = 100;  
long lo = a; // 正确 隐式类型转换

long lon = 100; // 正确。 既然是正确的 那么为什么老师一直说 让我在long类 型的数据后面 加一个L呢 实在不懂。

System.out.println(100); // 100 是int类型

//System.out.println(10000000000); //100亿 int类型 (int类型的数据 最大到21亿左右)  
// 此时 报错了， 100亿已经超过了int数据类型  
// 但是 直接写一个 整数常量 确实就是int类型的啊， 所以肯定报错。  
// 所以 我们就想 我们能不能写一个整数的时候 让jvm把他当做是一个long类型的数据呢，  
而不是int呢， 可以啊 你只需要在数据后面加一个 L就可以了。

System.out.println(10000000000L);

long lo = 100;  
\}  
\} \`\`\`

### 运算符 ###

> 运算符包括： 算术运算符、赋值运算符、逻辑运算符、比较运算符、三元运算符、位运算符

*  运算符：对常量或者变量进行操作的**符号**
 *  表达式：用**运算符** 把常量或者变量连接起来**符合java语法的式子** 就可以称为表达式。
 *  不同运算符连接的表达式体现的是不同类型的表达式。
 *  int c = a + b;
    
     *  \+：是运算符，并且是算术运算符
     *  a + b：是表达式，由于+是算术运算符，所以这个表达式叫算术表达式。表达式不能单独成语句。
 *  注意事项:
    
     *  \+，-有时也会代表正负号。
     *  但+号也会作为拼接符去参与字符串的加法。

`java System.out.println(+10); // 10 此时+号代表是 正号 System.out.println(-10); // -10 此时-号代表的是 负号`

*  /
    
    1.  整数相除得到的都是整数，要想得到小数 就必须有小数参与运算。
    2.  当整数除以 0 的时候(`10 / 0`)，会抛出异常：

`java Exception in thread "main" java.lang.ArithmeticException: / by zero at com.itwanger.eleven.ArithmeticOperator.main(ArithmeticOperator.java:32)`

3. 需要注意的是，当浮点数除以 0 的时候，结果为 Infinity 或者 NaN。

> Infinity 的中文意思是无穷大，NaN 的中文意思是这不是一个数字(Not a Number)。

`plain System.out.println(10.0 / 0.0); // Infinity System.out.println(0.0 / 0.0); // NaN`

> 所以整数在进行除法运算时，需要先判断除数是否为 0，以免程序抛出异常。

*  %
    
    1.  取模的结果 的符号 和 %号左侧的数的符号一致。
 *  \++ 和 --
    
    1.  无论放在任何的位置 这个变量经过 自身就会加1
    2.  \++放在变量的后面 整体取的是 变量还没有+1的值。
    3.  \++放在变量的前面 整体取的是 变量+1之后的值。
    4.  常量不能自己自加自减，否则会直接报错。

#### 比较运算符 ####

> < >= <= == !=

> 比较运算符运算出来的结果 全部都是 boolean类型数据

#### 逻辑运算符 ####

> 我们可以这样说，逻辑运算符，是用来**连接关系表达式**的运算符。 当然，逻辑运算符也可以直接**连接布尔类型的常量或者变量**。

*  & : 并且的意思 并且， 有假则假。 有false则false
 *  \\| ： 或者的意思 或者， 有真则真， 有true 则true
 *  ^ : 异或 异 ：不同 ， 如果是 不同， true， 不是 false
 *   *  异或 这是逻辑运算符 只能运算 boolean类型 也就是说 ^ 两侧只能写true false

#### 短路逻辑运算符 ####

*  && 和& 的结果是一样的。&& 效率高。并且， 有false则false。 如果左侧看到false了 右侧就不执行了。
 *  || 和| 的结果是一样的。|| 效率高。 或者， 有true则true。 如果左侧看到true了 右侧就不执行了
    
     *  逻辑与\*\*&\*\*，无论左边真假，右边都要执行。
     *  短路与\*\*&&**，如果左边为真，右边执行；如果**左边为假，右边不执行\*\*。
     *  逻辑或\*\*|\*\*，无论左边真假，右边都要执行。
     *  短路或\*\*||**，如果左边为假，右边执行；如果**左边为真，右边不执行\*\*。

#### 三元运算符 ####

\* \* 关系表达式 ? 表达式1 : 表达式2

*   参与此运算的数据的个数 只能是3个

#### 位运算符 ####

& | \\~ ^

![img][img 2]

*  和逻辑运算符基本是一样的， 只不过 逻辑运算符运算的true和false 位运算符运算的是1和0 ，你就可以 把1当做true 把0当做false 然后进行逻辑运算。
 *  & 有0则0 任何数 和0 去与运算 都是0
 *  \\| 有1则1 同种类型里面 一个数 和 同种类型里面的最大数 去或运算 得到 最大数
 *  \\~ 非0则1 \\~x = -(x+1)
 *  ^ 或 不同则true 对应1 相同则false 对应0 两个相同的数 异或 结果是0，规律: 一个数和0去异或 得到自身。 一个数 和另外一个数异或两次 还是自身。
 *  << 左移 \*2^
 *  有符号右移 /2^

\`\`\`java int a = 60, b = 13; System.out.println("a 的二进制：" + Integer.toBinaryString(a)); // 111100 System.out.println("b 的二进制：" + Integer.toBinaryString(b)); // 1101

int c = a & b; System.out.println("a & b：" + c + "，二进制是：" + Integer.toBinaryString(c));

c = a | b; System.out.println("a | b：" + c + "，二进制是：" + Integer.toBinaryString(c));

c = a ^ b; System.out.println("a ^ b：" + c + "，二进制是：" + Integer.toBinaryString(c));

c = ~a; System.out.println("~a：" + c + "，二进制是：" + Integer.toBinaryString(c));

c = a << 2; System.out.println("a << 2：" + c + "，二进制是：" + Integer.toBinaryString(c));

c = a >> 2; System.out.println("a >> 2：" + c + "，二进制是：" + Integer.toBinaryString(c));

c = a >>> 2; System.out.println("a >>> 2：" + c + "，二进制是：" + Integer.toBinaryString(c)); \`\`\`

### 选择语句 ###

#### if语句 ####

**if的三种使用格式：**

*  格式一：

`java if ( boolean类型数据 ){ //如果...... 语句体; // 如果条件为 true，则执行这块代码 }`

*  格式二：

`java if (条件表达式){ //如果......否则 语句体1; // 条件为 true 时执行的代码块 }else{ 语句体2; // 条件为 false 时执行的代码块 }`

*  格式三：

`java if (条件表达式1){ //存在多种选择情况 语句体1; // 条件1 为 true 时执行的代码 }else if (条件表达式2){ 语句体2; // 条件2 为 true 时执行的代码 }else if (条件表达式3){ 语句体3; // 条件3 为 true 时执行的代码 }else{ 语句体6; // 以上条件均为 false 时执行的代码 }`

**if嵌套语句:**

`java if(外侧条件){ // 外侧条件为 true 时执行的代码 if(内侧条件){ // 内侧条件为 true 时执行的代码 } }`

#### switch语句 ####

*  格式：

`java switch (表达式或者变量){ case 常量值1: // case ....的情况 语句1; // 可选值1匹配后执行的代码; break; //break 用来结束switch的。// 该关键字是可选项 case 常量值2: 语句2; break; case 常量值3: 语句3; break; ..... default : // 所有可选值都不匹配后执行的代码 语句3; break; }`

**switch的注意事项：**

1.  case后面 必须是常量 如果是变量就报错
2.  case不能重复判断。(值必须是唯一的，不能重复，否则会报错。)
3.  switch 的小括号内 里面只能放的数据类型 是比int小的 byte short char int String 枚举
4.  switch 的default 可以省略
5.  switch 的default 可以放在任意的位置。
    
         虽然 default的位置可以任意放，但是执行顺序是不变的， 依然也是 先看所有的case, 当所有的case都不满了之后 才去看default

break的作用 是为了结束 switch的， break可以省略，但是你省略了之后 就会发生case穿透现象。

> **case穿透应用场景：当发现switch语句中，多个case给出的语句体出现了重复的，就可以考虑使用case穿透来优化代码**

**switch和if的比较:**

1.  能用switch的地方 一定可以使用if的第三种格式去表示的。 但是 能用if的第三种格式 是不一定能用switch去表示的。因为 switch只能表示单个值的判断， 而if的第三种格式 可以对单个值 以及 范围去判断。
2.  既然所有的事情 if都可以做 为毛还要有switch呢？？ a.if可以判断范围,也可以判断一个值switch只能判断指定的值。 b.若只判断指定的值,则使用switch语句,效率快 if判断范围,对数据判断灵活,自身的格式也比较灵活。

> 当对大量的单个值进行判断的时候 switch的效率 明显高于 if 文章：[https://www.bilibili.com/read/cv5912019][https_www.bilibili.com_read_cv5912019]

### 循环语句 ###

#### for循环语句 ####

**普通的 for 循环可以分为 4 个部分：**

\`\`\`plain 1)初始变量：循环开始执行时的初始条件。

2)条件：循环每次执行时要判断的条件，如果为 true，就执行循环体；如果为 false，就跳出循环。当然了， 条件是可选的，如果没有条件，则会一直循环。

3)循环体：循环每次要执行的代码块，直到条件变为 false。

4)自增/自减：初识变量变化的方式。 \`\`\`

*  格式：

\`\`\`java for ( 初始化语句 ; 条件表达式 ; 控制循环语句)\{ 循环体; \}

真实格式：for (语句; boolean类型数据 ; 语句)语句;

for(初识变量;条件;自增/自减)\{  
// 循环体 \} \`\`\`

**for-each**

for-each 循环通常用于遍历数组和集合，它的使用规则比普通的 for 循环还要简单，不需要初始变量，不需要条件，不需要下标来自增或者自减。

`java for(元素类型 元素 : 数组或集合){ // 要执行的代码 }`

**for循环的死循环:**

\`\`\`java for ( ; ; )\{

\} \`\`\`

#### while 循环语句 ####

*  格式：

\`\`\`java 初始化语句; while (条件表达式)\{ 循环体; 控制循环语句; \}

真实格式：while(boolean类型数据)语句; \`\`\`

**while循环的死循环：**

\`\`\`java while (true)\{

\} \`\`\`

**for和while循环的比较：**

1.  他俩在任何的情况下 都是可以互换的， 能用for的地方 一定可以使用while的， 能用while 也必定可以使用for
2.  用途习惯不一样， 一般 有明确范围的地方 用都用for 没有明确范围的地方用while

#### do...while循环语句 ####

*  格式：

\`\`\`java int a = 0; // 初始化语句 do\{ System.out.println("aa"); //循环体 a++; // 条件控制语句 \}while (a<3); //条件判断

//dowhile执行的流程：第一次执行不判断，直接执行，从第二次开始正常先判断后执行。 \`\`\`

**do...while循环的死循环：**

\`\`\`java do\{

\}while (true); \`\`\`

### 循环控制语句 ###

*  break ：只能写在switch 或者 循环中， 终止循环。

> 还可以在某个指定的循环前面加上标号 例如： lo: for()\{\} 用于跳出某个特定的循环

*  continue ：只能写在 循环中， 跳过此次循环，继续执行下一次循环。该语句单独存在时，下面不可以定义语句，执行不到。

> 虽然使用break和continue关键字能够更方便的控制循环，但是注意在多重循环嵌套下，他只对离它最近的循环生效(就近原则)；

[img]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/e08d4d37c02442bbb4d1634178042057.png
[img 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/91c5e634c0384b3b82716596d0926425.png
[img 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/1a83410287d642c3b14ea2f46d79ed52.png
[https_www.bilibili.com_read_cv5912019]: https://www.bilibili.com/read/cv5912019